New in VLFL-Lib 1.0

Last change of this page: 2017-07-14
exp_2014_05_25 (fname,sx,sy,sz,th,ps)- reads an image file and generates a STL File for printing
exp_2014_05_25 (fname,sx,sy,sz,th,ps) % exp_2014_05_25 (fname,sx,sy,sz,th,ps) - reads an image file and
% generates a STL File for printing
% (by Tim Lueth, VLFL-Lib, 2014-MAI-25 as class: SYNTHESIZING PROCEDURES)
%
% This procedure was requested by Dr. Duffner of company Arburg as just
% as a small gadget. In contrast to exp_2014_05_15 and exp_2014_05_20
% this procedure is able to process graysscale images and covert it into
% 3D reliefs. (Status of: 2014-11-17)
%
% exp_2014_05_25([fname,sx,sy,sz,th,ps])
% === INPUT PARAMETERS ===
% fname: filename of an image file
% sx: size in x in mm
% sy: size in y in mm
% sz: size in z in mm
% th: text height over plate
% ps: Pixel size (n=sx/ps)
%
% EXAMPLE: Simply convert a PNG Image/Signature:
% exp_2014_05_20
%
exp_2014_05_20 (fname,sx,sy,sz,th,ps)- reads an image file and generates a STL File for printing
exp_2014_05_20 (fname,sx,sy,sz,th,ps) % exp_2014_05_20 (fname,sx,sy,sz,th,ps) - reads an image file and
% generates a STL File for printing
% (by Tim Lueth, VLFL-Lib, 2014-MAI-20 as class: SYNTHESIZING PROCEDURES)
%
% This procedure was requested by Dr. Duffner of company Arburg just as a
% small gadget. The procedures works similar to VLFLtextimage. This
% procedure is able to scale the original image to an requested printer
% resolution (should not be the optimal solution for solving resolution
% problems). (Status of: 2014-05-25)
%
% exp_2014_05_20([fname,sx,sy,sz,th,ps])
% === INPUT PARAMETERS ===
% fname: filename of an image file
% sx: size in x in mm
% sy: size in y in mm
% sz: size in z in mm
% th: text height over plate
% ps: Pixel size (n=sx/ps)
%
% EXAMPLE: Simply convert a PNG Image/Signature:
% exp_2014_05_20
%
exp_2014_05_15 (fname,sx,sy,sz,th,r)- reads an image file and generates a STL File for printing
exp_2014_05_15 (fname,sx,sy,sz,th,r) % exp_2014_05_15 (fname,sx,sy,sz,th,r) - reads an image file and
% generates a STL File for printing
% (by Tim Lueth, VLFL-Lib, 2014-MAI-16 as class: SYNTHESIZING PROCEDURES)
%
% This procedure was requested by Dr. Duffner of company Arburg as just
% as a small gadget. The procedures works similar to VLFLtextimage. This
% is the first procedure, that does not scale the original image but just
% scale the size of the STL. (Status of: 2014-05-20)
%
% exp_2014_05_15([fname,sx,sy,sz,th,r])
% === INPUT PARAMETERS ===
% fname: filename of an image file
% sx: size in x in mm
% sy: size in y in mm
% sz: size in z in mm
% th: text height over plate
% r: desired resolution
%
VLFLinpolyhedron()- returns the isInside Flag for a SG and a VL
VLFLinpolyhedron() % VLFLinpolyhedron() - returns the isInside Flag for a SG and a VL
% (by MATLAB-CENTRAL, VLFL-Lib, 2014-FEB-25 as class: SURFACES)
%
% very fast checking fnctn for points that are not on the surface.
%
% This fnctn still has some bugs with vertices on the surface of the
% solid (Status of: 2017-01-02)
%
% See also: mesh2mesh, BBiscollofVL, SGisInterior, VLcrossingSG,
% crossingfacets2VLFL
%
% IN=VLFLinpolyhedron([])
% === OUTPUT RESULTS ======
% IN: Vertex index list
%
% EXAMPLE: Test the probleatic surface points if this fnctn:
% A=SGbox([30,20,10]);
% VLcrossingSG(A,SGtrans(A,rotdeg(90)));
% VL=VLcrossingSG(A,SGtrans(A,rotdeg(90)));
% VL=unique(VL,'rows');
% SGisInterior(A,VL)
%
%
DTofPLELz(PL,EL,z)- returns a Delaunay Tetrahedron for a point list and edge list
DTofPLELz(PL,EL,z) % DTofPLELz(PL,EL,z) - returns a Delaunay Tetrahedron for a point list
% and edge list
% (by Tim Lueth, VLFL-Lib, 2014-JAN-14 as class: MODELING PROCEDURES)
%
% Work in progress
% First experiment to switch from surfaces to tetrahedron representation.
% In contrast to a solid geometry, a Delaunay Tetrahedron is not only the
% surface desciption, but the complete solid consist of tetrahedron,
% which outer (free hull) is the solid geoemetry surface
% If a triangle [1 2 3] is extruded using the points [4 5 6]
% we get three tetrahedrons [4 1 3 2;6 4 3 2; 6 5 4 2]
%
% We will need several procedures of this type:
% DTofPLELz (PL,EL,z)
% DTofCPLz (CPL,z)
% DTofPLFLz
%
% Work was interrrupted on 2014-01-14 (Status of: 2014-12-06)
%
% dt=DTofPLELz(PL,EL,z)
% === INPUT PARAMETERS ===
% PL: Point list for generating a delaunay tesselation in 2D
% EL: Edge list for the boundary constraints in 2D
% z: for the height in z of the solid
% === OUTPUT RESULTS ======
% dt:
%
% EXAMPLE:
% PL=[0 0; 10 0; 0 5]
%
exp_2014_01_13(H,B,n,DX,DY,WY,WZ)- EXPERIMENTAL Collection of boolean operators on solids (Delaunay)
exp_2014_01_13(H,B,n,DX,DY,WY,WZ) % exp_2014_01_13(H,B,n,DX,DY,WY,WZ) - EXPERIMENTAL Collection of boolean
% operators on solids (Delaunay)
% (by Tim Lueth, VLFL-Lib, 2014-JAN-13 as class: EXPERIMENTS)
%
% This is the first version of really usable boolean operators on solid
% geometries.
% It still has some bugs:
% (Status of: 2014-01-13)
%
% [dtX,XVL,XFL]=exp_2014_01_13([H,B,n,DX,DY,WY,WZ])
% === INPUT PARAMETERS ===
% H: Height of the object, default=23
% B: Width of the object, default=16
% n: number of edges, default=23
% DX: Shift in x, default=-5
% DY: Shift in y, default=+9
% WY: rotation angle Y, default 0
% WZ: rotation angle Z, default 0
% === OUTPUT RESULTS ======
% dtX: Triprep of the intersecting part
% XVL: Vertex list of the intersecting part
% XFL: Facet list of the intersecting part
%
% EXAMPLE: Powerfull examples
% exp_2014_01_10 (-1);
% exp_2014_01_10 (-3);
% exp_2014_01_10 (-6);
% exp_2014_01_10 (-1,-1);
%
VLFLplotmanifold (VL,FL);- plots a the non manifold points, edges, and facets of a solid
VLFLplotmanifold (VL,FL); % VLFLplotmanifold (VL,FL); - plots a the non manifold points, edges, and
% facets of a solid
% (by Tim Lueth, VLFL-Lib, 2014-JAN-12 as class: VISUALIZATION)
%
% facets have different colors depending on the number of isolated edges:
% green: ok
% blue: one edge of the facet is free
% magenta: two edges of the facet are free
% red: three edges of the facet are free
% cyan: All edges that are free (Status of: 2014-11-24)
%
% VLFLplotmanifold(VL,FL);
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: WORK in PROGRESS
%
exp_2014_01_11(H,B,n,DX,DY,WY,WZ)- EXPERIMENTAL Collection of boolean operators on solids
exp_2014_01_11(H,B,n,DX,DY,WY,WZ) % exp_2014_01_11(H,B,n,DX,DY,WY,WZ) - EXPERIMENTAL Collection of boolean
% operators on solids
% (by Tim Lueth, VLFL-Lib, 2014-JAN-11 as class: EXPERIMENTS)
%
% This is the first version of really usable boolean operators on solid
% geometries.
% It still has some bugs:
% (Status of: 2014-01-12)
%
% [dtX,XVL,XFL]=exp_2014_01_11([H,B,n,DX,DY,WY,WZ])
% === INPUT PARAMETERS ===
% H: Height of the object, default=23
% B: Width of the object, default=16
% n: number of edges, default=23
% DX: Shift in x, default=-5
% DY: Shift in y, default=+9
% WY: rotation angle Y, default 0
% WZ: rotation angle Z, default 0
% === OUTPUT RESULTS ======
% dtX: Triprep of the intersecting part
% XVL: Vertex list of the intersecting part
% XFL: Facet list of the intersecting part
%
% EXAMPLE: Powerfull examples
% exp_2014_01_10 (-1);
% exp_2014_01_10 (-3);
% exp_2014_01_10 (-6);
% exp_2014_01_10 (-1,-1);
%
CPLunitePLFL(PL,AFL)- returns the enclosing contour point list for a 2D triangulated surface
CPLunitePLFL(PL,AFL) % CPLunitePLFL(PL,AFL) - returns the enclosing contour point list for a
% 2D triangulated surface
% (by Tim Lueth, VLFL-Lib, 2014-JAN-11 as class: ANALYTICAL GEOMETRY)
%
% Uses polybool to connect the individual contour of the gives facets to
% prepare the contour. IF there is a NaN in the results, some facets were
% not connects (inside/separated). Use Plreassign to convert the CPL to
% the original point list (Status of: 2014-12-26)
%
% See also: CPLunite, CPLuniteCPL, CPLunitePLFL
%
% CPL=CPLunitePLFL(PL,AFL)
% === INPUT PARAMETERS ===
% PL: Point list (2D)
% AFL: Facet List
% === OUTPUT RESULTS ======
% CPL: Contour point list
%
% EXAMPLE: Create a CPL from a planar tesselated surface
% PL=PLcircseg(10,[],-pi/6,pi)
% FL=FLofn(size(PL,1))
% VLFLplot (PL,FL)
% CPL=CPLunitePLFL(PL,FL); CPLplot(CPL,'m',4)
%
PLFLofCPLdelaunay(CPL,ADDVL)- Returns 2D point list and facet list of a triangulated contour
PLFLofCPLdelaunay(CPL,ADDVL) % PLFLofCPLdelaunay(CPL,ADDVL) - Returns 2D point list and facet list of a triangulated contour
% (by Tim Lueth, VLFL-Lib, 2014-JAN-11 as class: ANALYTICAL GEOMETRY)
%
% For ONE closed contour given by a (polybool) contour list, this fnctn
% generates a tessellation by using the DelaunayTri fnctns. Without
% adding the desired points, the fnctn return a tesselation with minimal
% points.
% (Status of: 2017-03-17)
%
% See also: FLofCPL, PLFLofCPLpoly, PLELofCPL, FLofPLEL
%
% [XPL,XFL]=PLFLofCPLdelaunay(CPL,[ADDVL])
% === INPUT PARAMETERS ===
% CPL: Contour point list (2D) of the enclosed surface
% ADDVL: Vertex list of additional points to include
% === OUTPUT RESULTS ======
% XPL: Point List (2D) of the
% XFL: Facet List of the enclosed surface
%
% EXAMPLE: Two examples of retesselate an existing surface
% PL=PLcircseg(10,[],-pi/6,pi)
% UFL=FLofn(size(PL,1))
% VLFLplot (PL,UFL)
% CPL=CPLunitePLFL(PL,UFL); CPLplot(CPL,'m',4)
% [VL,FL]=PLFLofCPLdelaunay(CPLunitePLFL(PL,UFL)); VLFLplot (VL,FL); %
% Minimal points used
% PLFLofCPLdelaunay(CPLunitePLFL(VL,UFL),VL) % All points are used
%
exp_2014_01_10(H,B,n,DX,DY,WY,WZ)- EXPERIMENTAL Collection of boolean operators on solids
exp_2014_01_10(H,B,n,DX,DY,WY,WZ) % exp_2014_01_10(H,B,n,DX,DY,WY,WZ) - EXPERIMENTAL Collection of boolean
% operators on solids
% (by Tim Lueth, VLFL-Lib, 2014-JAN-10 as class: EXPERIMENTS)
%
% This is the first version of really usable boolean operators on solid
% geometries.
% It still has some bugs:
% (Status of: 2014-01-10)
%
% [dtX,XVL,XFL]=exp_2014_01_10([H,B,n,DX,DY,WY,WZ])
% === INPUT PARAMETERS ===
% H: Height of the object, default=23
% B: Width of the object, default=16
% n: number of edges, default=23
% DX: Shift in x, default=-5
% DY: Shift in y, default=+9
% WY: rotation angle Y, default 0
% WZ: rotation angle Z, default 0
% === OUTPUT RESULTS ======
% dtX: Triprep of the intersecting part
% XVL: Vertex list of the intersecting part
% XFL: Facet list of the intersecting part
%
% EXAMPLE: Powerfull examples
% exp_2014_01_10 (-1);
% exp_2014_01_10 (-3);
% exp_2014_01_10 (-6);
% exp_2014_01_10 (-1,-1);
%
VLFLDelaunayVL(VL)- Converts or Displays the Tetrahedrons of a Vertex List
VLFLDelaunayVL(VL) % VLFLDelaunayVL(VL) - Converts or Displays the Tetrahedrons of a Vertex
% List
% (by Tim Lueth, VLFL-Lib, 2014-JAN-10 as class: AUXILIARY PROCEDURES)
%
% [VL,FL]=VLFLDelaunayVL(VL)
% === INPUT PARAMETERS ===
% VL: Original Vertex list
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet List
%
% EXAMPLE: Displays the tetrahedrons of a cube:
% VLFLfigure; VLFLDelaunayVL(VLFLbox(30,20,10))
%
exp_2014_01_09 (H,B,n,DX,DY,WY,WZ)- EXPERIMENT for spatial Boolean operations
exp_2014_01_09 (H,B,n,DX,DY,WY,WZ) % exp_2014_01_09 (H,B,n,DX,DY,WY,WZ) - EXPERIMENT for spatial Boolean
% operations
% (by Tim Lueth, VLFL-Lib, 2014-JAN-09 as class: EXPERIMENTS)
%
% This experiment works but still have two problems.
% 1st: Detect the removed/exchanged facets (simple)
% 2nd: Conversion of polyeder based facet collection into one
% (retesselation) (Status of: 2014-01-09)
%
% exp_2014_01_09([H,B,n,DX,DY,WY,WZ])
% === INPUT PARAMETERS ===
% H: Height of the object, default=23
% B: Width of the object, default=16
% n: number of edges, default=23
% DX: Shift in x, default=-5
% DY: Shift in y, default=+9
% WY: rotation angle Y, default 0
% WZ: rotation angle Z, default 0
%
% EXAMPLE: Powerfull examples
% exp_2014_01_04 (25,10,30,6,8) ; (Sphere)
% exp_2014_01_04(25,80,30,5,0) ; (Box)
%
signthr(x)- returns a sign function related to a threshold
signthr(x) % signthr(x) - returns a sign fnctn related to a threshold
% (by Tim Lueth, VLFL-Lib, 2014-JAN-08 as class: AUXILIARY PROCEDURES)
%
% s=signthr(x)
% === INPUT PARAMETERS ===
% x: value
% === OUTPUT RESULTS ======
% s: sign
%
CPLofPLFL(PL,FL,bound)- returns a polybool contour from PL and FL
CPLofPLFL(PL,FL,bound) % CPLofPLFL(PL,FL,bound) - returns a polybool contour from PL and FL
% (by Tim Lueth, VLFL-Lib, 2014-JAN-08 as class: AUXILIARY PROCEDURES)
%
% This fnctn generates 4 points plus a NaN for each facet of FL.
% if 3rd parameter is true it converts a surface into a CPL. (Status of:
% 2017-05-23)
%
% CPL=CPLofPLFL(PL,FL,[bound])
% === INPUT PARAMETERS ===
% PL: Point list
% FL: Facet list
% bound: if true; the boundaries are
% === OUTPUT RESULTS ======
% CPL: Contour point list
%
% EXAMPLE: Create a CPL from a planar tesselated surface
% [PL,FL]=PLFLofCPLdelaunay(CPLsample(11));
% CPLofPLFL(PL,FL)
% CPLofPLFL(PL,FL,true)
%
exp_2014_01_07 (H,B,n,DX,DY,WY,WZ)- EXPERIMENT for spatial Boolean operations
exp_2014_01_07 (H,B,n,DX,DY,WY,WZ) % exp_2014_01_07 (H,B,n,DX,DY,WY,WZ) - EXPERIMENT for spatial Boolean
% operations
% (by Tim Lueth, VLFL-Lib, 2014-JAN-07 as class: EXPERIMENTS)
%
% This experiment really works and is a combination of using 2D/3D
% Delaunay but for intersection planes the polybool concept is used! DONT
% CHANGE, procedures works (Status of: 2014-01-09)
%
% exp_2014_01_07([H,B,n,DX,DY,WY,WZ])
% === INPUT PARAMETERS ===
% H: Height of the object, default=23
% B: Width of the object, default=16
% n: number of edges, default=23
% DX: Shift in x, default=-5
% DY: Shift in y, default=+9
% WY: rotation angle Y, default 0
% WZ: rotation angle Z, default 0
%
% EXAMPLE: Powerfull examples
% exp_2014_01_04 (25,10,30,6,8) ; (Sphere)
% exp_2014_01_04(25,80,30,5,0) ; (Box)
%
PLELofCPL(CPL)- converts a polybool contour point list to point list and edge list
PLELofCPL(CPL) % PLELofCPL(CPL) - converts a polybool contour point list to point list and edge list
% (by Tim Lueth, VLFL-Lib, 2014-JAN-07 as class: AUXILIARY PROCEDURES)
%
% This fnctn removes the NaN from the original point list. The
% orientation (cw/ccw) is not changed. (Status of: 2017-03-17)
%
% See also: FLofCPL, PLFLofCPLpoly, PLFLofCPLdelaunay, FLofPLEL
%
% [PL,EL]=PLELofCPL(CPL)
% === INPUT PARAMETERS ===
% CPL: Polybool contour point list
% === OUTPUT RESULTS ======
% PL: Point list (without NaN)
% EL: Edge list
%
% EXAMPLE:
% PLA=PLcircle(10); PLB=PLA*2; PLC=PLA*3;
% PLD=[PLA;NaN NaN;PLB;NaN NaN;PLC]
% VLplot(PLD)
% PLFLofCPLdelaunay(CPLpolybool('-',PLC,CPLpolybool('-',PLB,PLA)))
% [PL,EL]=PLFLofCPLdelaunay(PLD);
% [VL,FL]=VLFLofPLELz(PL,EL,20);
% VLFLfigure; VLFLplot(VL,FL)
%
PLFLofCPLpoly(CPL)- Utilizes the poly2fv function for VLFL-LIb
PLFLofCPLpoly(CPL) % PLFLofCPLpoly(CPL) - Utilizes the poly2fv fnctn for VLFL-LIb
% (by Tim Lueth, VLFL-Lib, 2014-JAN-06 as class: ANALYTICAL GEOMETRY)
%
% The point list is 2D and sorted by increasing y, contour by contour, so
% that the facets of different segments do not mix. The tessellation is a
% simple increasing order triangle segmentation, less efficient than
% DelaunayTri. For 3D solids, it makes sense to retessellate the contours
% by PLELofCPL. (Status of: 2017-03-17)
%
% See also: FLofCPL, PLFLofCPLdelaunay, PLELofCPL, FLofPLEL
%
% [PL,FL]=PLFLofCPLpoly(CPL)
% === INPUT PARAMETERS ===
% CPL: Contour points list
% === OUTPUT RESULTS ======
% PL: Point list
% FL: Facet list
%
% EXAMPLE:
% PL=PLcircseg(10,[],-pi/6,pi)
% [VL,FL]=PLFLofCPLpoly(PL); VLFLplot (VL,FL); % Minimal points used
%
CPLpolybool(flag,CPLA,CPLB,s)- Utilizes the polybool function for VLFL-LIb
CPLpolybool(flag,CPLA,CPLB,s) % CPLpolybool(flag,CPLA,CPLB,s) - Utilizes the polybool fnctn for VLFL-LIb
% (by Tim Lueth, VLFL-Lib, 2014-JAN-06 as class: ANALYTICAL GEOMETRY)
%
% Few days developing the PLELboolA_Bx fnctns, I detected that the
% Mapping-Toolbox contains these fnctns. All problematic special cases
% are covered! (Status of: 2015-08-16)
%
% [CPLN]=CPLpolybool(flag,CPLA,CPLB,[s])
% === INPUT PARAMETERS ===
% flag: Contour point list
% CPLA: Contour point list
% CPLB: operator (help polybool)
% s:
% === OUTPUT RESULTS ======
% [CPLN]:
%
% EXAMPLE: PLA=PLcircle(10); PLB=PLA*2; PLC=PLA*3;
% PLD=[PLA;NaN NaN;PLB;NaN NaN;PLC]
% VLplot(PLD)
% PLFLofCPL(CPLpolybool('-',PLC,CPLpolybool('-',PLB,PLA)))
%
exp_2014_01_06a- Experiment to test VLFLintersectedges
exp_2014_01_06a % exp_2014_01_06a - Experiment to test VLFLintersectedges
% (by Tim Lueth, VLFL-Lib, 2014-JAN-06 as class: EXPERIMENTS)
%
% exp_2014_01_06a
%
exp_2014_01_06 (H,B,n,DX,DY,WY,WZ)- EXPERIMENT for spatial Boolean operations
exp_2014_01_06 (H,B,n,DX,DY,WY,WZ) % exp_2014_01_06 (H,B,n,DX,DY,WY,WZ) - EXPERIMENT for spatial Boolean
% operations
% (by Tim Lueth, VLFL-Lib, 2014-JAN-06 as class: EXPERIMENTS)
%
% 1st experiment that works for some cases (drill trough)
% It has still some problems with the inner facets such as AFLB
% [AVLA,AFLA,AFLB]=VLFLboolTEST (VLA,FLA,VLB,FLB) (Status of: 2014-01-06)
%
% exp_2014_01_06([H,B,n,DX,DY,WY,WZ])
% === INPUT PARAMETERS ===
% H: Height of the object, default=23
% B: Width of the object, default=16
% n: number of edges, default=23
% DX: Shift in x, default=-5
% DY: Shift in y, default=+9
% WY: rotation angle Y, default 0
% WZ: rotation angle Z, default 0
%
% EXAMPLE: Powerfull examples
% exp_2014_01_04 (25,10,30,6,8) ; (Sphere)
% exp_2014_01_04(25,80,30,5,0) ; (Box)
%
exp_2014_01_07a- EXPERIMENT to separate a solid into thetrahedrons
exp_2014_01_07a % exp_2014_01_07a - EXPERIMENT to separate a solid into thetrahedrons
% (by Tim Lueth, VLFL-Lib, 2014-JAN-06 as class: EXPERIMENTS)
%
% this is not working, but shows a little bit the idea (Status of:
% 2014-01-07)
%
% exp_2014_01_07a
%
exp_2014_01_05 (H,B,n,DX,DY,WY,WZ)- EXPERIMENT for spatial Boolean operations
exp_2014_01_05 (H,B,n,DX,DY,WY,WZ) % exp_2014_01_05 (H,B,n,DX,DY,WY,WZ) - EXPERIMENT for spatial Boolean
% operations
% (by Tim Lueth, VLFL-Lib, 2014-JAN-05 as class: EXPERIMENTS)
%
% 1st experiment that works for some cases (drill trough)
% It has still some problems with the inner facets such as AFLB
% [AVLA,AFLA,AFLB]=VLFLboolTEST (VLA,FLA,VLB,FLB) (Status of: 2014-01-05)
%
% exp_2014_01_05([H,B,n,DX,DY,WY,WZ])
% === INPUT PARAMETERS ===
% H: Height of the object, default=23
% B: Width of the object, default=16
% n: number of edges, default=23
% DX: Shift in x, default=-5
% DY: Shift in y, default=+9
% WY: rotation angle Y, default 0
% WZ: rotation angle Z, default 0
%
% EXAMPLE: Powerfull examples
% exp_2014_01_04 (25,10,30,6,8) ; (Sphere)
% exp_2014_01_04(25,80,30,5,0) ; (Box)
%
exp_2014_01_04 (H,B,n,DX,DY)- EXPERIMENT for spatial Boolean operations
exp_2014_01_04 (H,B,n,DX,DY) % exp_2014_01_04 (H,B,n,DX,DY) - EXPERIMENT for spatial Boolean operations
% (by Tim Lueth, VLFL-Lib, 2014-JAN-03 as class: EXPERIMENTS)
%
% ..next try.. (Status of: 2014-01-04)
%
% exp_2014_01_04([H,B,n,DX,DY])
% === INPUT PARAMETERS ===
% H: Height of the object, default=23
% B: Width of the object, default=16
% n: number of edges, default=23
% DX: Shift in x, default=-5
% DY: Shift in y, default=+9
%
% EXAMPLE: Powerfull examples
% exp_2014_01_04 (25,10,30,6,8) ; (Sphere)
% exp_2014_01_04(25,80,30,5,0) ; (Box)
%
THLof2F(F1,F2)- returns Tetrahedron list of two facets
THLof2F(F1,F2) % THLof2F(F1,F2) - returns Tetrahedron list of two facets
% (by Tim Lueth, VLFL-Lib, 2014-JAN-03 as class: ANALYTICAL GEOMETRY)
%
% THL=THLof2F(F1,F2)
% === INPUT PARAMETERS ===
% F1: 1x3 Facet
% F2: 1x3 Facet
% === OUTPUT RESULTS ======
% THL: Single tetrahedron
%
% EXAMPLE: Tetrahedron of 2 triangle indices:
% THLof2F([1 2 3],[4 5 6])
%
%
VLFLintersectedges(VLA,FLA,VLB,FLB)- returns the intersecting edges of 2 solids
VLFLintersectedges(VLA,FLA,VLB,FLB) % VLFLintersectedges(VLA,FLA,VLB,FLB) - returns the intersecting edges of
% 2 solids
% (by Tim Lueth, VLFL-Lib, 2014-JAN-03 as class: ANALYTICAL GEOMETRY)
%
% procedure uses crossingfacets2VLFL
% The intersecting edge list has the format
% [start index IPL, end index IPL, Facet A, Facet B] (Status of:
% 2014-01-04)
%
% [IPL,IEL]=VLFLintersectedges(VLA,FLA,VLB,FLB)
% === INPUT PARAMETERS ===
% VLA: Vertex list A
% FLA: Facet list A
% VLB: Vertex list B
% FLB: Facet list B
% === OUTPUT RESULTS ======
% IPL: New intersection points list
% IEL: Edge list plus two colums related to Facet in A and in B
%
exp_2014_01_02- EXPERIMENT to realize clip able rotational links
exp_2014_01_02 % exp_2014_01_02 - EXPERIMENT to realize clip able rotational links
% (by Tim Lueth, VLFL-Lib, 2014-JAN-02 as class: EXPERIMENTS)
%
% exp_2014_01_02
%
PLELboolAmBx(PLAorg,ELA,PLBorg,ELB)- returns A minus B: Subtraction set of two 2D Point closed contours
PLELboolAmBx(PLAorg,ELA,PLBorg,ELB) % PLELboolAmBx(PLAorg,ELA,PLBorg,ELB) - returns A minus B: Subtraction
% set of two 2D Point closed contours
% (by Tim Lueth, VLFL-Lib, 2014-JAN-01 as class: ANALYTICAL GEOMETRY)
%
% Same procedure as PLELboolAmB, but this procedures works also with
% overlapping edges and points. This procedure uses PLELpushin to shift
% edges of contour B inside contour A if required. (Status of:
% 2014-01-01)
%
% [PLN,ELN,FLN]=PLELboolAmBx(PLAorg,ELA,PLBorg,ELB)
% === INPUT PARAMETERS ===
% PLAorg: Point List A
% ELA: Edge Lists A
% PLBorg: Point List B
% ELB: Edge Lists B
% === OUTPUT RESULTS ======
% PLN: New Point list containing PLA without PLB
% ELN: Edge list of contour A without contour B
% FLN: Facet list of contour A without contour B
%
PLELboolAuBx(PLAorg,ELA,PLBorg,ELB)- returns union set of two 2D Point closed contours
PLELboolAuBx(PLAorg,ELA,PLBorg,ELB) % PLELboolAuBx(PLAorg,ELA,PLBorg,ELB) - returns union set of two 2D Point
% closed contours
% (by Tim Lueth, VLFL-Lib, 2014-JAN-01 as class: ANALYTICAL GEOMETRY)
%
% Same procedure as PLELboolAuB, but this procedures works also with
% overlapping edges and points. This procedure uses PLELpushin to shift
% edges of contour B inside contour A if required. (Status of:
% 2014-01-01)
%
% [PLN,ELN,FLN]=PLELboolAuBx(PLAorg,ELA,PLBorg,ELB)
% === INPUT PARAMETERS ===
% PLAorg: Point List A
% ELA: Edge Lists A
% PLBorg: Point List B
% ELB: Edge Lists B
% === OUTPUT RESULTS ======
% PLN: New Point list containing PLA and PLB and crossing Points
% ELN: Edge list of union set
% FLN: Facet list of union set
%
PLELboolAiBx(PLAorg,ELA,PLBorg,ELB)- returns A intersects B: Intersection set of two 2D Point closed contours
PLELboolAiBx(PLAorg,ELA,PLBorg,ELB) % PLELboolAiBx(PLAorg,ELA,PLBorg,ELB) - returns A intersects B:
% Intersection set of two 2D Point closed contours
% (by Tim Lueth, VLFL-Lib, 2014-JAN-01 as class: ANALYTICAL GEOMETRY)
%
% Same procedure as PLELboolAiB, but this procedures works also with
% overlapping edges and points. This procedure uses PLELpushin to shift
% edges of contour B inside contour A if required. (Status of:
% 2014-01-01)
%
% [PLN,ELN,FLAiB]=PLELboolAiBx(PLAorg,ELA,PLBorg,ELB)
% === INPUT PARAMETERS ===
% PLAorg: Point List A
% ELA: Edge Lists A
% PLBorg: Point List B
% ELB: Edge Lists B
% === OUTPUT RESULTS ======
% PLN: New Point list containing PLA and PLB and crossing points
% ELN: Edge list of intersection contour
% FLAiB: Facet list of intersection contour
%
exp_2014_01_01(RA,DS,B,RI,R2,H,shaft)- Experiment to generate a 2.5D drill
exp_2014_01_01(RA,DS,B,RI,R2,H,shaft) % exp_2014_01_01(RA,DS,B,RI,R2,H,shaft) - Experiment to generate a 2.5D
% drill
% (by Tim Lueth, VLFL-Lib, 2014-JAN-01 as class: EXPERIMENTS)
%
% Exactly the same fnctn as 2013_12_25, but this time, the fnctns
% PLbooA_Bx are used that allow overlapping and coincident points (Status
% of: 2016-12-27)
%
% See also: PLtubbing, exp_2013_12_25
%
% [PLN,ELN,VLN,FLN]=exp_2014_01_01([RA,DS,B,RI,R2,H,shaft])
% === INPUT PARAMETERS ===
% RA: Outer radius
% DS: Thickness of blades
% B: Thickness of cross
% RI: Inner radius of axle
% R2: Outer radius of axle
% H: Height of the drill
% shaft: true=with axle
% === OUTPUT RESULTS ======
% PLN: Point list of 2D contour
% ELN: Edge list of 2D contour
% VLN: Vertex list of drill
% FLN: Facet list of drill
%
%
PLELcheckerr(PL,EL,slicence)- checks whether a point list and edge list are correct
PLELcheckerr(PL,EL,slicence) % PLELcheckerr(PL,EL,slicence) - checks whether a point list and edge
% list are correct
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-29 as class: ANALYTICAL GEOMETRY)
%
% Auxiliary procedure for debugging and development
% Error-Bits:
% 1. Coincident points exist
% 2. More end points than start points
% 3. More start points than end points
% 4. Obsolete points exist
% 5. Crossing points exist
% 6. New edges to define
% 7. Corrupted contours (Status of: 2013-12-30)
%
% [err,dt]=PLELcheckerr(PL,EL,slicence)
% === INPUT PARAMETERS ===
% PL: Point list
% EL: Edge list
% slicence: true = no terminal output; default is true
% === OUTPUT RESULTS ======
% err: error code
% dt: DelaunayTri
%
PLELDelaunay(PL,EL)- return the Delaunay Triangulation
PLELDelaunay(PL,EL) % PLELDelaunay(PL,EL) - return the Delaunay Triangulation
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-28 as class: ANALYTICAL GEOMETRY)
%
% This procedure is exactly the DelaunayTri without any modifications but
% different warnings are switched off (Status of: 2014-01-03)
%
% [PLN,ELN,FLall,in,FLin,FLout,warn]=PLELDelaunay(PL,EL)
% === INPUT PARAMETERS ===
% PL: Point list
% EL: Edge list
% === OUTPUT RESULTS ======
% PLN: Point list could have changed
% ELN: edge list could have changed
% FLall: Delaunay triangulation
% in: inside/outside status
% FLin: FLall(in,:)
% FLout: FLall(~in,:)
% warn: last warn result
%
PLELpushin(PLA,ELA,PLB,thr)- pushes points of contour B into contour A
PLELpushin(PLA,ELA,PLB,thr) % PLELpushin(PLA,ELA,PLB,thr) - pushes points of contour B into contour A
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-28 as class: ANALYTICAL GEOMETRY)
%
% For Boolean operations of plane surfaces, it is important to make sure
% that NO point of a contour B is on a point or edge of contour A.
% Otherwise the result of a Delaunay-Triangulation is unpredictable
% incorrect. To solve this problem, we move all points of B that are on
% the contour of A inside(!) contour A. Therefor, it is necessary that
% the edge list of A is complete and sorted using the right hand rule.
% Please use ELreconnect and ELflip to make sure that all contours of A
% are definitely in correct order
% WORK under progress. SLOW AND DIRTY AT THE MOMENT (Status of:
% 2013-12-28)
%
% PLB=PLELpushin(PLA,ELA,PLB,[thr])
% === INPUT PARAMETERS ===
% PLA: Point list A
% ELA: Edge list of A (right hand order)
% PLB: Point list B to test and shift
% thr: shift value; default = 1e-12
% === OUTPUT RESULTS ======
% PLB: Shifted point list
%
ELofFLborder(FL)- returns the border edges of a open 3D or closed 2D surface
ELofFLborder(FL) % ELofFLborder(FL) - returns the border edges of a open 3D or closed 2D
% surface
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-27 as class: AUXILIARY PROCEDURES)
%
% This procedure works only for correct Delaunay surfaces. Use
% PLFLofCPLpoly and CPLunitePLFL(PL,AFL) if this is not the sure. (Status
% of: 2014-01-12)
%
% [EL,CIL]=ELofFLborder(FL)
% === INPUT PARAMETERS ===
% FL: Facet list
% === OUTPUT RESULTS ======
% EL: Edge list
% CIL: contour index list
%
PLELboolABcheck (PLA,ELA,PLB,ELB)- checks the spatial relationship of two contour planes
PLELboolABcheck (PLA,ELA,PLB,ELB) % PLELboolABcheck (PLA,ELA,PLB,ELB) - checks the spatial relationship of
% two contour planes
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-27 as class: ANALYTICAL GEOMETRY)
%
% Tool for analyzing and understanding boolean operators:
% AinB A fully in B
% BinA B fully in A
% AsepB A separated from B (Status of: 2013-12-28)
%
% PLELboolABcheck(PLA,ELA,PLB,ELB)
% === INPUT PARAMETERS ===
% PLA: Point list A
% ELA: Edge list A
% PLB: Point list B
% ELB: Edge list B
%
PLtransP(PL,p)- returns a translated point list
PLtransP(PL,p) % PLtransP(PL,p) - returns a translated point list
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-27 as class: AUXILIARY PROCEDURES)
%
% See also: PLtransP, PLtransR, PLtrans, PLtrans0, PLtrans1, PLtransT
%
% PL=PLtransP(PL,p)
% === INPUT PARAMETERS ===
% PL: Point list nx2
% p: translation vector 1x2
% === OUTPUT RESULTS ======
% PL: Translated point list
%
exp_2013_12_27- EXPERIMENT to explain boolean operations
exp_2013_12_27 % exp_2013_12_27 - EXPERIMENT to explain boolean operations
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-27)
%
% exp_2013_12_27
%
PLELplot(PL,EL,c,w)- plots a 2D contur by PL and EL
PLELplot(PL,EL,c,w) % PLELplot(PL,EL,c,w) - plots a 2D contur by PL and EL
% (by Tim Lueth, HT-Lib, 2013-DEZ-27 as class: VISUALIZATION)
%
% h=PLELplot(PL,EL,[c,w])
% === INPUT PARAMETERS ===
% PL: Point list of x/y coordinates nx2
% EL: Edge list
% c: Color and symbol of points
% w: Width of the used line
% === OUTPUT RESULTS ======
% h: Handles to Lines
%
PLplot(PL,c,w,vec,a)- plots a 2D polygon in a 3D figure
PLplot(PL,c,w,vec,a) % PLplot(PL,c,w,vec,a) - plots a 2D polygon in a 3D figure
% (by Tim Lueth, HT-Lib, 2013-DEZ-27 as class: VISUALIZATION)
%
% PL is a nx2 point list with x/y coordinates (Status of: 2017-02-08)
%
% See also: VLELplots, CPLplot, VLplot
%
% h=PLplot(PL,[c,w,vec,a])
% === INPUT PARAMETERS ===
% PL: Point list of x/y coordinates nx2
% c: Color and symbol of points
% w: Width of the used line
% vec: if v>0, vectors are plotted from the origin
% a: transparancy; default is 0;
% === OUTPUT RESULTS ======
% h: Handle to figure
%
% EXAMPLE:
% PLplot(PLcircle(10),'b-',4,'',0.9);
%
exp_2013_12_26a- Experiment to test the PLELboolean Procedures
exp_2013_12_26a % exp_2013_12_26a - Experiment to test the PLELboolean Procedures
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-26 as class: EXPERIMENTS)
%
% exp_2013_12_26a
%
exp_2013_12_26- EXPERIMENT to generate a flexible hinge drill
exp_2013_12_26 % exp_2013_12_26 - EXPERIMENT to generate a flexible hinge drill
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-26 as class: EXPERIMENTS)
%
% exp_2013_12_26
%
PLELboolAiB(PLA,ELA,PLB,ELB)- returns A intersects B: Intersection set of two 2D Point closed contours
PLELboolAiB(PLA,ELA,PLB,ELB) % PLELboolAiB(PLA,ELA,PLB,ELB) - returns A intersects B: Intersection set
% of two 2D Point closed contours
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-26 as class: ANALYTICAL GEOMETRY)
%
% procedure to generate a subtraction set based on two contours
% PLELboolAuB = A union B (belongs to A or B)
% PLELboolAiB = A intersection B (belongs to A and to B)
% PLELboolAmB = A minus B (belongs to A and is not in B)
% Afterwards use if required:
% [PLN,ELN]=VLELshort(PLN,ELN); ELN=ELreconnect(ELN);
% FLN=FLofPLEL(PLN,ELN);
% (Status of: 2013-12-26)
%
% [PLN,ELN,FLAiB]=PLELboolAiB(PLA,ELA,PLB,ELB)
% === INPUT PARAMETERS ===
% PLA: Point List A
% ELA: Edge Lists A
% PLB: Point List B
% ELB: Edge Lists B
% === OUTPUT RESULTS ======
% PLN: New Point list containing PLA and PLB and crossing points
% ELN: Edge list of intersection contour
% FLAiB: Facet list of intersection contour
%
PLtubbing(RI,RA,n,phiA,phiB)- returns a points list for a 2D tubbing
PLtubbing(RI,RA,n,phiA,phiB) % PLtubbing(RI,RA,n,phiA,phiB) - returns a points list for a 2D tubbing
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-25 as class: MODELING PROCEDURES)
%
% [PL,EL]=PLtubbing(RI,RA,[n,phiA,phiB])
% === INPUT PARAMETERS ===
% RI: Inner radius
% RA: Outer radius
% n: optionl n
% phiA: starting angle
% phiB: ending angle
% === OUTPUT RESULTS ======
% PL: Point list
% EL: Edge list
%
PLELboolAmB(PLA,ELA,PLB,ELB)- returns A minus B: Subtraction set of two 2D Point closed contours
PLELboolAmB(PLA,ELA,PLB,ELB) % PLELboolAmB(PLA,ELA,PLB,ELB) - returns A minus B: Subtraction set of
% two 2D Point closed contours
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-25 as class: ANALYTICAL GEOMETRY)
%
% procedure to generate a subtraction set based on two contours
% PLELboolAuB = A union B (belongs to A or B)
% PLELboolAiB = A intersection B (belongs to A and to B)
% PLELboolAmB = A minus B (belongs to A and is not in B)
% Afterwards use if required:
% [PLN,ELN]=VLELshort(PLN,ELN); ELN=ELreconnect(ELN);
% FLN=FLofPLEL(PLN,ELN);
% (Status of: 2014-01-01)
%
% [PLN,ELN,FLAmB]=PLELboolAmB(PLA,ELA,PLB,ELB)
% === INPUT PARAMETERS ===
% PLA: Point List A
% ELA: Edge Lists A
% PLB: Point List B
% ELB: Edge Lists B
% === OUTPUT RESULTS ======
% PLN: New Point list containing PLA without PLB
% ELN: Edge list of contour A without contour B
% FLAmB: Facet list of contour A without contour B
%
PLELboolAuB(PLA,ELA,PLB,ELB)- returns union set of two 2D Point closed contours
PLELboolAuB(PLA,ELA,PLB,ELB) % PLELboolAuB(PLA,ELA,PLB,ELB) - returns union set of two 2D Point closed
% contours
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-25 as class: ANALYTICAL GEOMETRY)
%
% procedure to generate a union set based on two contours
% PLELboolAuB = A union B (belongs to A or B)
% PLELboolAiB = A intersection B (belongs to A and to B)
% PLELboolAmB = A minus B (belongs to A and is not in B)
% Afterwards use if required:
% [PLN,ELN]=VLELshort(PLN,ELN); ELN=ELreconnect(ELN);
% FLN=FLofPLEL(PLN,ELN);
% (Status of: 2014-01-01)
%
% [PLN,ELN,FLAuB]=PLELboolAuB(PLA,ELA,PLB,ELB)
% === INPUT PARAMETERS ===
% PLA: Point List A
% ELA: Edge Lists A
% PLB: Point List B
% ELB: Edge Lists B
% === OUTPUT RESULTS ======
% PLN: New Point list containing PLA and PLB and crossing Points
% ELN: Edge list of union set
% FLAuB: Facet list of union set
%
exp_2013_12_25(RA,DS,B,RI,R2,H,shaft)- Experiment to generate a 2.5D drill
exp_2013_12_25(RA,DS,B,RI,R2,H,shaft) % exp_2013_12_25(RA,DS,B,RI,R2,H,shaft) - Experiment to generate a 2.5D
% drill
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-25 as class: EXPERIMENTS)
%
% [PLN,ELN,VLN,FLN]=exp_2013_12_25([RA,DS,B,RI,R2,H,shaft])
% === INPUT PARAMETERS ===
% RA: Outer radius
% DS: Thickness of blades
% B: Thickness of cross
% RI: Inner radius of axle
% R2: Outer radius of axle
% H: Height of the drill
% shaft: true=with axle
% === OUTPUT RESULTS ======
% PLN: Point list of 2D contour
% ELN: Edge list of 2D contour
% VLN: Vertex list of drill
% FLN: Facet list of drill
%
exp_2013_12_24(PLA,ELA,PLB,ELB)- Exactly the same as exp_2013_08_18 but this time using PLA, ELA, PLB, ELB
exp_2013_12_24(PLA,ELA,PLB,ELB) % exp_2013_12_24(PLA,ELA,PLB,ELB) - Exactly the same as exp_2013_08_18
% but this time using PLA, ELA, PLB, ELB
% (by Tim Lueth, VLFL-Lib, 2013-DEZ-24 as class: EXPERIMENTS)
%
% [VL,EL,A,B,AiL,BiL,ie1,ie2,ce]=exp_2013_12_24(PLA,ELA,PLB,ELB)
% === INPUT PARAMETERS ===
% PLA: Point list A
% ELA: Edge list A
% PLB: Point list B
% ELB: Edge List B
% === OUTPUT RESULTS ======
% VL: Vertex list
% EL: Edge list
% A: Points inside A list
% B: Points inside B list
% AiL: One point inside Edge list index
% BiL: Two point inside Edge list index
% ie1: both point additional edge list index
%
% EXAMPLE: Generate the new contour edges
% APL=find(AiL==0), BPL=find(BiL==0), CPL=find(AiL==0&BiL==0)
% AEL=EL(ismember(EL(:,1),APL)&ismember(EL(:,2),APL),:)
% BEL=EL(ismember(EL(:,1),BPL)&ismember(EL(:,2),BPL),:)
% CEL=EL(ismember(EL(:,1),CPL)&ismember(EL(:,2),CPL),:)
%
EXP_2013_10_09- EXPERIMENT that solves symbolic equation for a 3bar-Linkage
EXP_2013_10_09 % EXP_2013_10_09 - EXPERIMENT that solves symbolic equation for a
% 3bar-Linkage
% (by Tim Lueth, VLFL-Lib, 2013-OKT-09 as class: EXPERIMENTS)
%
% On the track of Reuleaux, Gruebler, Beyer and Denavit-Hartenberg, it is
% important to understand the difference between calculation of the
% geometry of losed kinematic chains and the degrees of freedom of a
% closed kinematic chain (loop).
% The equation is solved by calculation the kinematic chain for the end
% of the 3rd link depending on the three angles wa wb wc first:
% C(wa,wb,wc)
% Next, we inspect the HT matrix of C and search for a solution when the
% [x;y] coordinates are [0;0]., i.e. the terms in the 3rd column of the
% first 2 rows of the procedure are zero.
% There will be not solution without a start point, since the whole
% structure could rotation either on wa, wb or wc. And independent on
% those rotations, the angles of the other two angles depend
% If la, lb, lc is set to 10 and wa to zeros; the solutions are: ±2pi/3.
% It is interesting that in fact just two joint angles define the closed
% loop (position).
% The third angle is used if also the rotation angle should be free; i.e.
% F(1,2). F(1,3). F(2,3) have to be zero. (Status of: 2013-10-09)
%
% EXP_2013_10_09
%
EXP_2013_10_07- EXPERIMENT that solves symbolic equation for a 3bar-Linkage
EXP_2013_10_07 % EXP_2013_10_07 - EXPERIMENT that solves symbolic equation for a
% 3bar-Linkage
% (by Tim Lueth, VLFL-Lib, 2013-OKT-07 as class: EXPERIMENTS)
%
% On the track of Reuleaux, Gruebler, Beyer and Denavit-Hartenberg, it is
% important to understand the difference between calculation of the
% geometry of losed kinematic chains and the degrees of freedom of a
% closed kinematic chain (loop).
% The equation is solved by calculation the kinematic chain for the end
% of the 3rd link depending on the three angles wa wb wc first:
% C(wa,wb,wc)
% Next, we inspect the HT matrix of C and search for a solution when the
% [x;y] coordinates are [0;0]., i.e. the terms in the 3rd column of the
% first 2 rows of the procedure are zero.
% There will be not solution without a start point, since the whole
% structure could rotation either on wa, wb or wc. And independent on
% those rotations, the angles of the other two angles depend
% If la, lb, lc is set to 10 and wa to zeros; the solutions are: ±2pi/3.
% It is interesting that in fact just two joint angles define the closed
% loop (position).
% The third angle is used if also the rotation angle should be free; i.e.
% F(1,2). F(1,3). F(2,3) have to be zero.
%
%
% (Status of: 2013-10-09)
%
% EXP_2013_10_07
%
Rofxy(x,y,wz)- Rotation matrix by the ez vektor and and optional rotation angle
Rofxy(x,y,wz) % Rofxy(x,y,wz) - Rotation matrix by the ez vektor and and optional
% rotation angle
% (by Tim Lueth, VLFL-Lib, 2013-SEP-29 as class: ANALYTICAL GEOMETRY)
%
% procedure described 2006 in the book draft of Tim Lueth. Without an
% explizit give rotation angle, the xvalue of ey is always zero, i.e
% R(1,2)=0;
% To generate this procedure the symbolic equation solver of Matlab was
% used! (Status of: 2013-09-29)
%
% R=Rofxy(x,y,[wz])
% === INPUT PARAMETERS ===
% x: x value of the ez vector
% y: y value of the ez vector
% wz: rotation angle, default is 0
% === OUTPUT RESULTS ======
% R: Rotation matrix 3x3
%
VLELCILplots (VL,EL,CIL,c,w,t,b,f)- plots contours given as vertex list and edge list
VLELCILplots (VL,EL,CIL,c,w,t,b,f) % VLELCILplots (VL,EL,CIL,c,w,t,b,f) - plots contours given as vertex
% list and edge list
% (by Tim Lueth, VLFL-Lib, 2013-SEP-29 as class: VISUALIZATION)
%
% This procedure draws a contour given by a vertex list (VL), edge list
% (EL) and contour index list (CIL) using VLELplots. (Status of:
% 2013-09-29)
%
% VLELCILplots(VL,EL,CIL,[c,w,t,b,f])
% === INPUT PARAMETERS ===
% VL: Vertex list
% EL: Edge list
% CIL: Contour index list
% c: Optional color of desired edges; default os 'r*-'
% w: Optional line width; default is 1
% t: Size of a cone shaped arrow tip, default is 0
% b: Size of a cube showing the start point of a contour; default is 0
% f: Size of a ring showing the end point of a contour; default is 0
%
exp_2013_09_29(anz,LL,GL)- EXPERIMENT to generate kinematic equations from VLui and an unsorted link list
exp_2013_09_29(anz,LL,GL) % exp_2013_09_29(anz,LL,GL) - EXPERIMENT to generate kinematic equations
% from VLui and an unsorted link list
% (by Tim Lueth, VLFL-Lib, 2013-SEP-29 as class: EXPERIMENTS)
%
% This experiment shows the automatic generation of equations of an
% unsorted node link list for a kinematic chain by LLsort
% Defines and uses the struct KC (Kinematic chain):
% KC.JL Joint List, cells
% KC.LL Link List, Array (n x 2)
% KC.LG Solid Arrat, Array (n) of SG (Status of: 2013-10-01)
%
% KC=exp_2013_09_29([anz,LL,GL])
% === INPUT PARAMETERS ===
% anz: number of joints; default is 4
% LL: Joint Link list
% GL: Base frame list
% === OUTPUT RESULTS ======
% KC: Joint list
%
% EXAMPLE: Analyze different configurations:
% mod=exp_2013_09_29 (4,[1 2;2 3;3 4]); % Simple serial link chain
% mod=exp_2013_09_29 (4,[1 2;2 3;3 4; 4 1]); % Simple closed link chain
% mod=exp_2013_09_29 (4,[1 2;2 3;3 4; 4 1],[1]); % Simple closed link
% chain with frame 1
% mod=exp_2013_09_29 (4,[1 2;2 3;3 4; 4 1],[1 2] ); % Simple closed link
% chain with frame 1 and 2
% mod=exp_2013_09_29 (5,[1 2;2 3;3 4; 2 5; 3 5; 4 5],[1]); % Simple
% closed link chain with frame 1
%
MMlinkage(JL,LL,i)- generates a symbolic equation for a linkage
MMlinkage(JL,LL,i) % MMlinkage(JL,LL,i) - generates a symbolic equation for a linkage
% (by Tim Lueth, VLFL-Lib, 2013-SEP-28 as class: MECHANICAL PROCEDURES)
%
% Generates the symbolic movement equation for a give linkage structure
% (Status of: 2013-09-29)
%
% F=MMlinkage(JL,LL,i)
% === INPUT PARAMETERS ===
% JL: Joint list
% LL: Link list
% i: link number
% === OUTPUT RESULTS ======
% F: Resulting equation
%
symfunparam(AF,L)- returns individualized string for symbolic parameters and definition
symfunparam(AF,L) % symfunparam(AF,L) - returns individualized string for symbolic
% parameters and definition
% (by Tim Lueth, VLFL-Lib, 2013-SEP-28 as class: AUXILIARY PROCEDURES)
%
% This procedure can be used for automation equation generation by the
% eval command. It is possible to use an existing symbolic equation to
% call it with modified parametersets. Important for the calucation of
% the movement equations in kinematic chains. (Status of: 2013-09-29)
%
% [vpar,vsyms]=symfunparam(AF,[L])
% === INPUT PARAMETERS ===
% AF: symbolic equation
% L: Letter for individual equation
% === OUTPUT RESULTS ======
% vpar: variable string (parameter separated by comma)
% vsyms: symbol definition string (parameter separated by space)
%
% EXAMPLE: Exa
% syms x y
% F(x,y)=cos(x)*sin(x)+cos(y)
% [par,sym]=symfunparam (F)
% [par,sym]=symfunparam (F,'A')
%
symfunchng(AF,L)- changes the parameter of a given equation
symfunchng(AF,L) % symfunchng(AF,L) - changes the parameter of a given equation
% (by Tim Lueth, VLFL-Lib, 2013-SEP-28 as class: AUXILIARY PROCEDURES)
%
% Within a kinematic chain, often the same equations are used to describe
% the DoF of a joint. During symbolic calculations it is necessary to
% distinguish the joint related parameter.
% F(x,y) => F(A_x,A_y) (Status of: 2013-09-28)
%
% [AF,a]=symfunchng(AF,L)
% === INPUT PARAMETERS ===
% AF: symbolic procedure
% L: Letter for specification of a joint
% === OUTPUT RESULTS ======
% AF: symbolic procedure with changed parameters
% a: argnames
%
% EXAMPLE: Change the angle w by a joint related angle A_w
% syms R(w);
% R(w)=[cos(w) -sin(w) 0 0;sin(w) cos(w) 0 0; 0 0 1 20+w; 0 0 0 1]
% F=symfun2sym(R,'A')
%
ginputTL(maxnr)- procedure similar to ginput
ginputTL(maxnr) % ginputTL(maxnr) - procedure similar to ginput
% (by Tim Lueth, VLFL-Lib, 2013-SEP-28 as class: USER INTERFACE)
%
% This procedure was written to be able to modify the ginput procedure to
% show additional information during the movement of the cursor. It is
% also possible to limit the maximum time for an interaction.
% It is similar to VLui and similar to ginput (Status of: 2013-09-28)
%
% VL=ginputTL([maxnr])
% === INPUT PARAMETERS ===
% maxnr: number of points to collect
% === OUTPUT RESULTS ======
% VL: Vertex list
%
% EXAMPLE: ginputTL(3)
%
exp_2013_09_27(anz)- EXPERIMENT to generate kinematic equations from VLui and an unsorted link list
exp_2013_09_27(anz) % exp_2013_09_27(anz) - EXPERIMENT to generate kinematic equations from
% VLui and an unsorted link list
% (by Tim Lueth, VLFL-Lib, 2013-SEP-27 as class: EXPERIMENTS)
%
% This experiment shows the automatic generation of equations of an
% unsorted node link list for a kinematic chain by LLsort
% Defines and uses the struct KC (Kinematic chain):
% KC.JL Joint List, cells
% KC.LL Link List, Array (n x 2)
% KC.LG Solid Arrat, Array (n) of SG (Status of: 2013-09-27)
%
% KC=exp_2013_09_27([anz])
% === INPUT PARAMETERS ===
% anz: number of joints; default is 4
% === OUTPUT RESULTS ======
% KC: Joint list
%
LLanalyze(LL)- Auxiliary function for classification of edges/joints
LLanalyze(LL) % LLsort.LLanalyze(LL) - Auxiliary fnctn for classification of edges/joints
% (by Tim Lueth, VLFL-Lib, 2013-SEP-26 as class: AUXILIARY PROCEDURES)
%
% This fnctn is currently used and part of LLsort
% The separation of joint connections by links is similar to the
% connection of vertex lists or point lists by edges. In both cases with
% consider that the order is important and we need some information on
% the used nodes / terminals.
% The joint classification list
% V(1)=sorted list of joints ascending order
% v(2)=number of following joints
% v(3)=number of predecessing joints
% v(4)=no branch point
% v(5)=open end point (Status of: 2017-01-05)
%
% [V,LL]=LLanalyze(LL)
% === INPUT PARAMETERS ===
% LL: Original link/edge list
% === OUTPUT RESULTS ======
% V: Node list including classification
% LL: Link list with only unique links
%
LLsort(LL,GL,VL)- sorts a kinematic chain list similar to an edge list
LLsort(LL,GL,VL) % LLsort(LL,GL,VL) - sorts a kinematic chain list similar to an edge list
% (by Tim Lueth, VLFL-Lib, 2013-SEP-24 as class: AUXILIARY PROCEDURES)
%
% Very powerful procedure to separate link lists or edge lists into
% Without a fixed joint list, LLsort plots the structure
% Without a vertex list, LL sorts generates all joints on a circle
% ====================================================
% Important is a Joint classification list (LLAnalyze)
% V(1)=sorted list of joints
% v(2)=number of following joints
% v(3)=number of predecessing joints
% v(4)=no branch point
% v(5)=open end point
% (Status of: 2013-09-26)
%
% [CIL,LLN,V]=LLsort([LL,GL,VL])
% === INPUT PARAMETERS ===
% LL: Link list (n x 2) of joints
% GL: Base list of static joints, optional [];
% VL: Vertex list, optional
% === OUTPUT RESULTS ======
% CIL: Connection index list
% LLN: Sorted Link List
% V: Node index list including classification
%
exp_2013_09_24- EXPERIMENT to generate kinematic description from VLui and an unsorted link list
exp_2013_09_24 % exp_2013_09_24 - EXPERIMENT to generate kinematic description from VLui
% and an unsorted link list
% (by Tim Lueth, VLFL-Lib, 2013-SEP-24 as class: EXPERIMENTS)
%
% This experiment shows the automatic analysis of an unsorted node link
% list for a kinematic chain by LLsort
% Defines and uses the struct KC (Kinematic chain):
% KC.JL Joint List, cells
% KC.LL Link List, Array (n x 2)
% KC.LG Solid Arrat, Array (n) of SG (Status of: 2013-09-27)
%
% KC=exp_2013_09_24
% === OUTPUT RESULTS ======
% KC: Joint list
%
exp_2013_09_22- EXPERIMENT to generate kinematic chains from VLui and a link list
exp_2013_09_22 % exp_2013_09_22 - EXPERIMENT to generate kinematic chains from VLui and
% a link list
% (by Tim Lueth, VLFL-Lib, 2013-SEP-22 as class: EXPERIMENTS)
%
% This experiment shows the move of individual links by using MMplot
% which are linked by a node link list similar to an edge list.
% Defines and uses the struct KC (Kinematic chain):
% KC.JL Joint List, cells
% KC.LL Link List, Array (n x 2)
% KC.LG Solid Arrat, Array (n) of SG (Status of: 2013-09-27)
%
% KC=exp_2013_09_22
% === OUTPUT RESULTS ======
% KC: Joint list
%
flipvar(a,b)- returns two flipped variable
flipvar(a,b) % flipvar(a,b) - returns two flipped variable
% (by Tim Lueth, VLFL-Lib, 2013-SEP-21 as class: AUXILIARY PROCEDURES)
%
% Attention, the order of variables change between input and output
% (Status of: 2014-12-26)
%
% See also: ELunsort, ELsort
%
% [b,a]=flipvar(a,b)
% === INPUT PARAMETERS ===
% a: Variable A
% b: Variable B
% === OUTPUT RESULTS ======
% b: Variable B
% a: Variable B
%
exp_2013_09_21- EXPERIMENT to generate kinematic chains
exp_2013_09_21 % exp_2013_09_21 - EXPERIMENT to generate kinematic chains
% (by Tim Lueth, VLFL-Lib, 2013-SEP-21 as class: EXPERIMENTS)
%
% Defines and uses the struct KC (Kinematic chain):
% KC.JL Joint List, cells
% KC.LL Link List, Array (n x 2)
% KC.LG Solid Arrat, Array (n) of SG (Status of: 2013-09-21)
%
% KC=exp_2013_09_21
% === OUTPUT RESULTS ======
% KC: Joint list
%
MMlink(MM1,MM2)- returns a solid bar geometry that connect two motion joints straight
MMlink(MM1,MM2) % MMlink(MM1,MM2) - returns a solid bar geometry that connect two motion
% joints straight
% (by Tim Lueth, VLFL-Lib, 2013-SEP-21 as class: MODELING PROCEDURES)
%
% used in exp_2013_09_20. (Status of: 2013-09-21)
%
% SGL=MMlink(MM1,MM2)
% === INPUT PARAMETERS ===
% MM1: Motion joint model A
% MM2: Motion joint model B
% === OUTPUT RESULTS ======
% SGL: Solid geometry bar
%
MMplot(A,T,parL)- plots /updates a joint in a given configuration on the screen
MMplot(A,T,parL) % MMplot(A,T,parL) - plots /updates a joint in a given configuration on
% the screen
% (by Tim Lueth, VLFL-Lib, 2013-SEP-21 as class: VISUALIZATION)
%
% If the joint figure/patch is not existing, this procedure draws the
% components. Otherwise the vertex list of the drawing is updated, so
% that is changes on the screen. Without a given parameter set, the
% default parameter are the minimal values of the joint definition
% (Status of: 2013-09-23)
%
% Anew=MMplot(A,[T,parL])
% === INPUT PARAMETERS ===
% A: Joint Model including solids
% T: Optional transformation matrix
% parL: optional parameter of the joint model
% === OUTPUT RESULTS ======
% Anew: A with updated handles
%
exp_2013_09_20- EXPERIMENT to generate kinematic chains
exp_2013_09_20 % exp_2013_09_20 - EXPERIMENT to generate kinematic chains
% (by Tim Lueth, VLFL-Lib, 2013-SEP-20 as class: EXPERIMENTS)
%
% This experiment allow the definition of a sequential kinematic chain,
% automatically generates the missing linkage bars between the joints and
% shows the movement of all of the bars. The links are generated in the
% order of the defined points (Status of: 2013-09-21)
%
% JL=exp_2013_09_20
% === OUTPUT RESULTS ======
% JL: Joint list
%
HTofT(T)- returns a 4x4 homogenous transformation matrix even for 2x2
HTofT(T) % HTofT(T) - returns a 4x4 homogenous transformation matrix even for 2x2
% (by Tim Lueth, VLFL-Lib, 2013-SEP-19 as class: AUXILIARY PROCEDURES)
%
% This procedure is used within MMplot to make 3D drawings even of 2
% dimensional joint definitions (Status of: 2013-09-19)
%
% HT=HTofT(T)
% === INPUT PARAMETERS ===
% T: transformation matrix (2x2, 3x3, 4x4)
% === OUTPUT RESULTS ======
% HT: transformation matrix (4x4)
%
MMplotmotion(A,T,defmax,PSL)- plots a motion sequence for the complete parameter space of a motion model
MMplotmotion(A,T,defmax,PSL) % MMplotmotion(A,T,defmax,PSL) - plots a motion sequence for the complete
% parameter space of a motion model
% (by Tim Lueth, VLFL-Lib, 2013-SEP-17 as class: VISUALIZATION)
%
% generates a motion sequence to show all possible configurations using a
% given stepsize (Status of: 2013-09-21)
%
% Asave=MMplotmotion(A,[T,defmax,PSL])
% === INPUT PARAMETERS ===
% A: Motion model
% T: HT matrix of the origin
% defmax: maximum numbers of steps per joint
% PSL: Parameter space list
% === OUTPUT RESULTS ======
% Asave: Modified model including parameter space and graphic handles
%
MMsolid(A)- generates a simple solid geometry model for a joint
MMsolid(A) % MMsolid(A) - generates a simple solid geometry model for a joint
% (by Tim Lueth, VLFL-Lib, 2013-SEP-17 as class: VISUALIZATION)
%
% Basic procedure in combination with MMjoint to generate joint models
% for simulation, and syntheses. The generic solid model is 10 x 10 x 10
% mm in size. Stator is blue, Actor is green. At a later stage, this
% procedure is used for automatic construction of the STL models. So
% MMsolid will have more parameters in future (Status of: 2013-09-17)
%
% A=MMsolid(A)
% === INPUT PARAMETERS ===
% A: Joint model generated with MMjoint
% === OUTPUT RESULTS ======
% A: Joint model includes solid date
%
symfun2sym(AF)- converts a symfun into a sym (=command formula)
symfun2sym(AF) % symfun2sym(AF) - converts a symfun into a sym (=command formula)
% (by Tim Lueth, VLFL-Lib, 2013-SEP-17 as class: AUXILIARY PROCEDURES)
%
% Same as matlab command: formula: Anyway you can learn something by
% reading it. procedure is existing in matlab already. This procedure is
% required if a symbolic equation matrix should be separated into
% individual elements. In this case F(1,1) describes row/column instead
% of procedure parameters (Status of: 2013-09-28)
%
% [AS,a]=symfun2sym(AF)
% === INPUT PARAMETERS ===
% AF: symbolic procedure
% === OUTPUT RESULTS ======
% AS: symbol separated procedure
% a: argnames
%
% EXAMPLE:
% syms R(w);
% R(w)=[cos(w) -sin(w) 0 0;sin(w) cos(w) 0 0; 0 0 1 20+w; 0 0 0 1]
% F=R, F(2)
% F=symfun2sym(R),F(3,4)
%
MMtype(JT,var1,var2,var3,var4)- returns a symbolic motion matrix as homogenous transformation matrix
MMtype(JT,var1,var2,var3,var4) % MMtype(JT,var1,var2,var3,var4) - returns a symbolic motion matrix as
% homogenous transformation matrix
% (by Tim Lueth, VLFL-Lib, 2013-SEP-16 as class: ANALYTICAL GEOMETRY)
%
% Important procedure to use symbolic equations:
% symvar
%
% (Status of: 2015-02-13)
%
% [F]=MMtype(JT,[var1,var2,var3,var4])
% === INPUT PARAMETERS ===
% JT: Joint type such as 'RwzTx'
% var1: replacement for variable 1
% var2: replacement for variable 2
% var3: replacement for variable 3
% var4: replacement for variable 4
% === OUTPUT RESULTS ======
% [F]: Symbolic movement matrix equation
%
% EXAMPLE: 3-Bar Linkage
% B=MMtype('RwzTx','b',40)
% C=MMtype('RwzTx','c',30)
% D=MMtype('RwzTx','d',20)
% T=B*C*D
% r=solve(T(1:3,4))
% x.b, x.c
% double(x.b)
% U(symvar(T))=T
% U(x.b(1),x.c(1),NaN)
% double(U(x.b(1),x.c(1),NaN))
%
MMjoint(Equat,jlimit,T0,T1,L)- returns a joint by a symbolic equation
MMjoint(Equat,jlimit,T0,T1,L) % MMjoint(Equat,jlimit,T0,T1,L) - returns a joint by a symbolic equation
% (by Tim Lueth, VLFL-Lib, 2013-SEP-16 as class: MECHANICAL PROCEDURES)
%
% This procedure models the movement equation of a joint. The degrees of
% freedom are given as homogenous transformation matrix for the TCP of
% the joint and a symbolic equation. Furthermore, the movement limits are
% given by the limits of the indivdual freedom parameter
%
% (Status of: 2013-09-20)
%
% [MM]=MMjoint(Equat,jlimit,[T0,T1,L])
% === INPUT PARAMETERS ===
% Equat: Symbolix equation of the moving frame
% jlimit: cell array of limits and steps
% T0: HT Matrix of the Joint base frame
% T1: HT Matrix of the Movement reference frame
% L: Individual letter for this joint
% === OUTPUT RESULTS ======
% [MM]: Motion model
%
% EXAMPLE: Generate a rotating 2D model (Think about using assume also)
% syms R(w)
% R(w)=[cos(w) -sin(w) 20;sin(w) cos(w) 30]
% mod=MMjoint (R,[0,inf,pi])
% mod.TM(2)
% mod.TM(pi)
% char(mod.TM(pi))
% a=argnames(mod.TM), a(1)
% solve(mod.TF(2,2),mod.TF(1,1))
%
exp_2013_09_16- EXPERIMENT fro development of Generic Joint Models
exp_2013_09_16 % exp_2013_09_16 - EXPERIMENT fro development of Generic Joint Models
% (by Tim Lueth, VLFL-Lib, 2013-SEP-16 as class: EXPERIMENTS)
%
% MMjoint is a genereric joint model that is developed during writing
% this experiment, directly after the gears / transmission / kinematic
% congress in Ilmenau (Status of: 2013-09-17)
%
% [A]=exp_2013_09_16
% === OUTPUT RESULTS ======
% [A]:
%
exp_2013_08_20(Ra,na,Rb,nb,mx,my)- EXPERIMENT for boolesche combination of closed edge contours
exp_2013_08_20(Ra,na,Rb,nb,mx,my) % exp_2013_08_20(Ra,na,Rb,nb,mx,my) - EXPERIMENT for boolesche
% combination of closed edge contours
% (by Tim Lueth, VLFL-Lib, 2013-AUG-20 as class: EXPERIMENTS)
%
% [VL,EL,AiL,BiL,ie1,ie2,ce]=exp_2013_08_20([Ra,na,Rb,nb,mx,my])
% === INPUT PARAMETERS ===
% Ra: Radius circle A; default 10
% na: number of edges Ra; default 4
% Rb: Radius circle B; default Ra
% nb: number of edges Rb; default na
% mx: distance in x; default Ra/2
% my: distance in y; default mx
% === OUTPUT RESULTS ======
% VL: Vertex list
% EL: Edge list
% AiL: Points inside A list
% BiL: Points inside B list
% ie1: One point inside Edge list index
% ie2: Two point inside Edge list index
% ce: both point additional edge list index
%
% EXAMPLE: Generate the new contour edges
% APL=find(AiL==0), BPL=find(BiL==0), CPL=find(AiL==0&BiL==0)
% AEL=EL(ismember(EL(:,1),APL)&ismember(EL(:,2),APL),:)
% BEL=EL(ismember(EL(:,1),BPL)&ismember(EL(:,2),BPL),:)
% CEL=EL(ismember(EL(:,1),CPL)&ismember(EL(:,2),CPL),:)
%
exp_2013_08_18(Ra,na,Rb,nb,mx,my)- EXPERIMENT for boolesche combination of closed edge contours
exp_2013_08_18(Ra,na,Rb,nb,mx,my) % exp_2013_08_18(Ra,na,Rb,nb,mx,my) - EXPERIMENT for boolesche
% combination of closed edge contours
% (by Tim Lueth, VLFL-Lib, 2013-AUG-18 as class: EXPERIMENTS)
%
% [VL,EL,AiL,BiL,ie1,ie2,ce]=exp_2013_08_18([Ra,na,Rb,nb,mx,my])
% === INPUT PARAMETERS ===
% Ra: Radius circle A; default 10
% na: number of edges Ra; default 4
% Rb: Radius circle B; default Ra
% nb: number of edges Rb; default na
% mx: distance in x; default Ra/2
% my: distance in y; default mx
% === OUTPUT RESULTS ======
% VL: Vertex list
% EL: Edge list
% AiL: Points inside A list
% BiL: Points inside B list
% ie1: One point inside Edge list index
% ie2: Two point inside Edge list index
% ce: both point additional edge list index
%
% EXAMPLE: Generate the new contour edges
% APL=find(AiL==0), BPL=find(BiL==0), CPL=find(AiL==0&BiL==0)
% AEL=EL(ismember(EL(:,1),APL)&ismember(EL(:,2),APL),:)
% BEL=EL(ismember(EL(:,1),BPL)&ismember(EL(:,2),BPL),:)
% CEL=EL(ismember(EL(:,1),CPL)&ismember(EL(:,2),CPL),:)
%
exp_2013_08_17a- EXPERIMENT to show boolean operations on 2 basic contours an edge lists
exp_2013_08_17a % exp_2013_08_17a - EXPERIMENT to show boolean operations on 2 basic
% contours an edge lists
% (by Tim Lueth, VLFL-Lib, 2013-AUG-17 as class: EXPERIMENTS)
%
% [PL,EL,FL]=exp_2013_08_17a
% === OUTPUT RESULTS ======
% PL:
% EL:
% FL:
%
exp_2013_08_17- EXPERIMENT FOR FDM/MARIE for the generation of flexible hinges, I need the FDM e modules / stress values
exp_2013_08_17 % exp_2013_08_17 - EXPERIMENT FOR FDM/MARIE for the generation of
% flexible hinges, I need the FDM e modules / stress values
% (by Tim Lueth, VLFL-Lib, 2013-AUG-17 as class: EXPERIMENTS)
%
% Generates 5 strips 45 mm x 10 x (0.6 0.8 1.0 1.2 1.4) mm (Status of:
% 2013-08-17)
%
% exp_2013_08_17
%
ELreconnect(EL)- resorts a valid but broken and recompiled edge list
ELreconnect(EL) % ELreconnect(EL) - resorts a valid but broken and recompiled edge list
% (by Tim Lueth, VLFL-Lib, 2013-AUG-16 as class: AUXILIARY PROCEDURES)
%
% Powerful recursive procedure. If this procedure fails by recursion, it
% is not a problem of the procedure, but of the list. This procedures has
% to be reprogrammed as not recursive soon
% Nevertheless, large problematic lists can crash Matlab. Please use
% set(0,'RecursionLimit',3000) (Status of: 2013-12-27)
%
% [EL,CIL,k]=ELreconnect(EL)
% === INPUT PARAMETERS ===
% EL: broken edge list
% === OUTPUT RESULTS ======
% EL: Edge list
% CIL: Contour index list
% k: number of changes required
%
CILofOEL(EL)- returns contour index list for a SORTED edge list of several consecutive open contours
CILofOEL(EL) % CILofOEL(EL) - returns contour index list for a SORTED edge list of
% several consecutive open contours
% (by Tim Lueth, VLFL-Lib, 2013-AUG-16 as class: AUXILIARY PROCEDURES)
%
% works with closed AND open contour edge lists which have to be SORTED
% first !
% CILofCEL CIL of contour edge list - CILofOEL CIL of open edge list
% (Status of: 2013-08-16)
%
% [CIL,ci,pi]=CILofOEL(EL)
% === INPUT PARAMETERS ===
% EL: Edge list
% === OUTPUT RESULTS ======
% CIL: Contour index list
% ci: real closed contur index list (without points)
% pi: single point contour index list
%
% EXAMPLE: Used in EXP-2013-08-13
% EL=[ELofn(3);ELofn(4)+3;ELofn(1)+5+3]
% UEL=[ELunsort(EL);EL]; [CIL,ci,pi]=CILofOEL(UEL)
%
exp_2013_08_19- EXPERIMENT that shows the crossing of 2 straight lines between 2 points
exp_2013_08_19 % exp_2013_08_19 - EXPERIMENT that shows the crossing of 2 straight lines
% between 2 points
% (by Tim Lueth, VLFL-Lib, 2013-AUG-16 as class: EXPERIMENTS)
%
% This procedure works only in 2D with [x y] coordinates (Status of:
% 2015-09-20)
%
% exp_2013_08_19
%
VLFLmeshdensity(VL,FL,maxd)- decreases the edge length of the facets for deformation use
VLFLmeshdensity(VL,FL,maxd) % VLFLmeshdensity(VL,FL,maxd) - decreases the edge length of the facets
% for deformation use
% (by Tim Lueth, VLFL-Lib, 2013-AUG-15 as class: ANALYTICAL GEOMETRY)
%
% Fast and powerful. Future activities: removement of doubles, parameter
% for interruption
% maximum number of edges/facets (Status of: 2013-08-15)
%
% [NVL,UFL,NFL]=VLFLmeshdensity(VL,FL,maxd)
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: facet list
% maxd: Maximal edge length
% === OUTPUT RESULTS ======
% NVL: New vertex list, contains doubles
% UFL: New facet list
% NFL: is always empty until procedure is not interrupted
%
% EXAMPLE: Generate edges no longer than 6 mm
% [VL,FL]=VLFLremesh(VL,FL,5);
% VL=roundn(VL,1e-5);[VL,~,C]=unique(VL,'rows','first'); FL=C(FL);
%
exp_2013_08_15- EXPERIMENT that recursively decreases the size of the facet edges until they are below a limited length
exp_2013_08_15 % exp_2013_08_15 - EXPERIMENT that recursively decreases the size of the
% facet edges until they are below a limited length
% (by Tim Lueth, VLFL-Lib, 2013-AUG-15 as class: EXPERIMENTS)
%
% It shows the use of procedure VLFLmeshdensity (Status of: 2013-08-15)
%
% [VL,FL]=exp_2013_08_15
% === OUTPUT RESULTS ======
% VL: Vertex List
% FL: Facet List
%
exp_2013_08_14b- EXPERIMENT that generates 4 spherical bars for 4 spherical 4bar linkage
exp_2013_08_14b % exp_2013_08_14b - EXPERIMENT that generates 4 spherical bars for 4
% spherical 4bar linkage
% (by Tim Lueth, VLFL-Lib, 2013-AUG-14 as class: EXPERIMENTS)
%
% Created using modern binpacking. There is still potential for an
% improved packaging method by analyzing convex hull of the solids
% before. (Status of: 2015-02-22)
%
% [VL,FL,VLI,FLI]=exp_2013_08_14b
% === OUTPUT RESULTS ======
% VL:
% FL:
% VLI:
% FLI:
%
VLFLrotsymRLELn(RL,CEL,n)- returns VL and FL for a torus style solid
VLFLrotsymRLELn(RL,CEL,n) % VLFLrotsymRLELn(RL,CEL,n) - returns VL and FL for a torus style solid
% (by Tim Lueth, VLFL-Lib, 2013-AUG-14 as class: ANALYTICAL GEOMETRY)
%
% This procedure rotates a contour given by point list and contour edge
% list. The code contains some very efficient formulation for closed
% calculations of surfaces. (Status of: 2013-08-14)
%
% [VL,FL]=VLFLrotsymRLELn(RL,CEL,[n])
% === INPUT PARAMETERS ===
% RL: Point list 2D
% CEL: Contour edge list
% n: number of point on the polygon; default is nofrd
% === OUTPUT RESULTS ======
% VL: Vertex list of torus solid
% FL: Facet list of torus solid
%
% EXAMPLE: RL=[5 0; 10 5; 15 10; 15 40],
% VLplot (RL,'r*-'), axis equal, view (0,90)
% [VL,FL]=VLFLrotsymRLELn (RL,CEL,40);
% VLFLplot (VL,FL,'m'), view (30,30)
%
VLdim3(PL)- converts a 2D PL into a 3D VL.
VLdim3(PL) % VLdim3(PL) - converts a 2D PL into a 3D VL.
% (by Tim Lueth, VLFL-Lib, 2013-AUG-14 as class: AUXILIARY PROCEDURES)
%
% This fnctn adds if required a 3rd dimension to a point list. Similar to
% VLaddz but less systematic (Status of: 2017-01-29)
%
% See also: VLaddz
%
% VL=VLdim3(PL)
% === INPUT PARAMETERS ===
% PL: Point list (2D) or vertex list (3D)
% === OUTPUT RESULTS ======
% VL: Vertex list (3D)
%
exp_2013_08_14- EXPERIMENT that generates 4 spherical bars for 4 spherical 4bar linkage
exp_2013_08_14 % exp_2013_08_14 - EXPERIMENT that generates 4 spherical bars for 4
% spherical 4bar linkage
% (by Tim Lueth, VLFL-Lib, 2013-AUG-13 as class: EXPERIMENTS)
%
% exp_2013_08_14
%
CILofCEL(EL)- returns contour index list for a correct edge list of several consecutive closed contours
CILofCEL(EL) % CILofCEL(EL) - returns contour index list for a correct edge list of
% several consecutive closed contours
% (by Tim Lueth, VLFL-Lib, 2013-AUG-13 as class: AUXILIARY PROCEDURES)
%
% works only for several consecutive closed contours edge lists! For each
% entry of the contour index list, i.e. for all contours, the last point
% of the last edge is the first point of the first edge
% EL(CIL(i,1),1) = EL(CIL(i,2),2)
% See
% CILofCEL CIL of contour edge list - CILofOEL CIL of open edge list
% (Status of: 2013-08-16)
%
% [CIL,err]=CILofCEL(EL)
% === INPUT PARAMETERS ===
% EL: Edge list
% === OUTPUT RESULTS ======
% CIL: Contour index list
% err: true if CIL is corrupted
%
% EXAMPLE: Used in EXP-2013-08-13
% EL=[ELofn(3);ELofn(4)+3;ELofn(1)+5+3]
% CILofCEL(EL)
%
exp_2013_08_13(RA,RI,H,R,phi)- Experiment that show the final use of VLFLspherecurvedPLEL
exp_2013_08_13(RA,RI,H,R,phi) % exp_2013_08_13(RA,RI,H,R,phi) - Experiment that show the final use of
% VLFLspherecurvedPLEL
% (by Tim Lueth, VLFL-Lib, 2013-AUG-13 as class: MODELING PROCEDURES)
%
% This procedure generates a spherical bar of a spherical 4-bar:
% VLFLspherelinkage (RA,RI,H,D,phi) (Status of: 2013-08-13)
%
% [VLX,FLX]=exp_2013_08_13([RA,RI,H,R,phi])
% === INPUT PARAMETERS ===
% RA: Outer Radius of the spherical bar
% RI: Outer Radius of the spherical bar
% H: Height of the spherical bar
% R: Radius of the sphere
% phi: angle (distance/R)
% === OUTPUT RESULTS ======
% VLX: Vertex list of the spherical bar
% FLX: Facet list of the spherical bar
%
CELflip(CEL)- Flips orientation of contour edge list
CELflip(CEL) % CELflip(CEL) - Flips orientation of contour edge list
% (by Tim Lueth, VLFL-Lib, 2013-AUG-13 as class: AUXILIARY PROCEDURES)
%
% Work similar to ELflip but handles the invidiual subsequent contours in
% the contour edge list independently (Status of: 2013-08-13)
%
% CEL=CELflip(CEL)
% === INPUT PARAMETERS ===
% CEL: Contour edge list
% === OUTPUT RESULTS ======
% CEL: Contour edge list flipped
%
% EXAMPLE:
% CEL=[1 2;2 3;3 4;4 1;5 6; 6 7;7 8;9 5]
% [CEL CELflip(CEL)]
%
ELflip(EL)- flips orientation of edge list
ELflip(EL) % ELflip(EL) - flips orientation of edge list
% (by Tim Lueth, VLFL-Lib, 2013-AUG-13 as class: AUXILIARY PROCEDURES)
%
% Does not support contour edge lists.
% EL=flipud(EL(:,[2 1]));
% (Status of: 2017-03-20)
%
% See also: FLswap, ELswap
%
% EL=ELflip(EL)
% === INPUT PARAMETERS ===
% EL: Edge list
% === OUTPUT RESULTS ======
% EL: Edge list flipped
%
% EXAMPLE: [EL ELswap(EL)]
%
VLFLspherecurvedPLEL(PL,CEL,R,d)- returns VL and FL for a sphere-curved surface given by a point list and contour edge list
VLFLspherecurvedPLEL(PL,CEL,R,d) % VLFLspherecurvedPLEL(PL,CEL,R,d) - returns VL and FL for a
% sphere-curved surface given by a point list and contour edge list
% (by Tim Lueth, VLFL-Lib, 2013-AUG-13 as class: ANALYTICAL GEOMETRY)
%
% This procedure is a combination of generating auxiliary points for the
% plane, the contour, for tesselation, and for transformation on a sphere
% surface. (Status of: 2013-08-13)
%
% [VL,FL,CEL]=VLFLspherecurvedPLEL(PL,CEL,R,d)
% === INPUT PARAMETERS ===
% PL: Point list 2D
% CEL: Contour edge list
% R: Radius [-R 0 0]
% d: maximum point distance of contour and grid
% === OUTPUT RESULTS ======
% VL: Vertex list of surface
% FL: Facet list of surface
% CEL: Contour edge list
%
GPLauxgridpointsPLEL(PL,EL,dx,dy)- returns for a given 2D contour point list auxiliary points to define a plane surface
GPLauxgridpointsPLEL(PL,EL,dx,dy) % GPLauxgridpointsPLEL(PL,EL,dx,dy) - returns for a given 2D contour point list auxiliary points to define a plane surface
% (by Tim Lueth, VLFL-Lib, 2013-AUG-13 as class: AUXILIARY PROCEDURES)
%
% The fnctn is based on a cartesian meshgrid that us reshaped to form a
% new points list. The fnctn uses insideC to generate the final index
% list (Status of: 2017-03-27)
%
% See also: PLFLofCPLdelaunay, RLaddauxpoints, RLdelauxpoints,
% GPLauxgridpointsCL, PLELaddauxpoints
%
% [GPL,k]=GPLauxgridpointsPLEL(PL,EL,dx,dy)
% === INPUT PARAMETERS ===
% PL: Point list 2D
% EL: Contour edge list [start end]
% dx: Maximum auxiliary points in x
% dy: Maximum auxiliary points in y
% === OUTPUT RESULTS ======
% GPL: Grid point list 2D
% k: index whether k is inside or outside the contour
%
% EXAMPLE: Generate auxiliary points for a circle
% RL=PLcircle(20);
% pplot (RL','bo-'); view (0,90); hold on; axis equal; axis auto;
% [GPL,k]=GPLauxgridpointsCL (RL,4,4);
% pplot (GPL(k==0,:)', 'b*'); % Already part of Contour
% pplot (GPL(k==1,:)', 'g*'); % Inside of Contour
% pplot (GPL(k==-1,:)','r*'); % Outside of Contour
%
insidePLEL(PL,CEL,P)- returns whether a point is inside/outside a contour
insidePLEL(PL,CEL,P) % insidePLEL(PL,CEL,P) - returns whether a point is inside/outside a contour
% (by Tim Lueth, VLFL-Lib, 2013-AUG-12 as class: ANALYTICAL GEOMETRY)
%
% ATTENTION: DOES NOT WORK WITH SEPARATED CONTOURS
% works only with 2D point list and a correct contour edge list. Used in
% GPLauxgridpointsPLEL to calculate auxiliary grid points inside a
% contour. Also used in PLELboolAiB and others (Status of: 2017-03-28)
%
% See also: insidePLELdelaunay
%
% tl=insidePLEL(PL,CEL,P)
% === INPUT PARAMETERS ===
% PL: 2D Point list
% CEL: Contour edge list
% P: point to check or point list
% === OUTPUT RESULTS ======
% tl: +1==inside, -1==outside, 0== on the contour
%
PLELaddauxpoints(PL,CEL,d)- add supporting points to a point list and a contour edge list
PLELaddauxpoints(PL,CEL,d) % PLELaddauxpoints(PL,CEL,d) - add supporting points to a point list and a contour edge list
% (by Tim Lueth, VLFL-Lib, 2013-AUG-12 as class: AUXILIARY PROCEDURES)
%
% This fnctn supports point lists and contours given by edge lists. In
% contrast to RLaddauxpoints, new points are not inserted but appended at
% the end of the points list. The new edges are inserted at the right
% position in the edge list to reach consequent edges in order. (Status
% of: 2017-03-27)
%
% See also: RLaddauxpoints, RLdelauxpoints, GPLauxgridpointsCL,
% GPLauxgridpointsPLEL
%
% [PL,CEL]=PLELaddauxpoints(PL,CEL,d)
% === INPUT PARAMETERS ===
% PL: Point list in 2D (but would work also with a 3D vertex list)
% CEL: Contour edge list
% d: maximum distance between two points
% === OUTPUT RESULTS ======
% PL: Point list in 2D (but would work also with a 3D vertex list)
% CEL: Contour edge list
%
FLofPLEL(PL,EL)- returns tessellation of a 2D points list and contour edge list
FLofPLEL(PL,EL) % FLofPLEL(PL,EL) - returns tessellation of a 2D points list and contour edge list
% (by Tim Lueth, VLFL-Lib, 2013-AUG-12 as class: AUXILIARY PROCEDURES)
%
% Uses Delaunay triangulation to tessellate a contour including
% additional contours.
% Checks whether DelaunayTri changes the point order (Status of:
% 2014-12-26)
%
% See also: FLofCPL, PLFLofCPLpoly, PLFLofCPLdelaunay, PLELofCPL
%
% [FLin,VL,EL,FLout]=FLofPLEL(PL,EL)
% === INPUT PARAMETERS ===
% PL: 2D Point list
% EL: Contour edge list
% === OUTPUT RESULTS ======
% FLin: Facet list inside
% VL: Vertex list could be longer
% EL: Edge List all
% FLout: Facet list outside
%
% EXAMPLE:
% CPL=[PLcircle(10); NaN NaN; PLcircle(4)];
% [PL,EL]=PLELofCPL(CPL);
% FLofPLEL(PL,EL);
%
FLcontourwallELn(EL,n)- returns the wall facets between 2 contours given by an edge list
FLcontourwallELn(EL,n) % FLcontourwallELn(EL,n) - returns the wall facets between 2 contours
% given by an edge list
% (by Tim Lueth, VLFL-Lib, 2013-AUG-12 as class: AUXILIARY PROCEDURES)
%
% This lines were used already in VLFLofPLELz.
% Could be a single line; n=max(EL) (Status of: 2013-08-12)
%
% FLW=FLcontourwallELn(EL,n)
% === INPUT PARAMETERS ===
% EL: Edge list for both contours
% n: number of points/vertices, if not n=max(EL)
% === OUTPUT RESULTS ======
% FLW: upright walls between the 2 contours
%
exp_2013_08_12-
exp_2013_08_12 % exp_2013_08_12 -
% (by Tim Lueth, VLFL-Lib, 2013-AUG-11 as class: EXPERIMENTS)
%
% exp_2013_08_12
%
exp_2013_08_11- Experiment to show th final use of VLFLspherecurvedCL
exp_2013_08_11 % exp_2013_08_11 - Experiment to show th final use of VLFLspherecurvedCL
% (by Tim Lueth, VLFL-Lib, 2013-AUG-11 as class: EXPERIMENTS)
%
% To curve a 2D contour on a spherical surface, we need
% a) auxiliary surface points inside of the contour
% b) auxiliary contour points on the contour to follow the curve
% c) Delaunay triangulation of the contour surface!
% d) Transformation of the vertices
% All of this is done by VLFLspherecurvedCL
% (Status of: 2013-08-11)
%
% exp_2013_08_11
%
VLFLspherecurvedCL(CL,R)- returns VL and FL for a sphere curved surface given by a 2D contour point list
VLFLspherecurvedCL(CL,R) % VLFLspherecurvedCL(CL,R) - returns VL and FL for a sphere curved
% surface given by a 2D contour point list
% (by Tim Lueth, VLFL-Lib, 2013-AUG-11 as class: ANALYTICAL GEOMETRY)
%
% This procedure is a combination of generating auxiliary points for the
% plane, the contour, for tesselation, and for transformation on a sphere
% surface. (Status of: 2013-08-11)
%
% [VL,FL,CVL,CL]=VLFLspherecurvedCL(CL,R)
% === INPUT PARAMETERS ===
% CL: Points list of 2D contour
% R: Radius [-R 0 0]
% === OUTPUT RESULTS ======
% VL: Vertex list of surface
% FL: Facet list of surface
% CVL: Contour Vertex list
% CL: Contour list (incl. auxiliary points)
%
exp_2013_08_10- EXPERIMENT similar to 2013_08_09 and the final 2013_08_11
exp_2013_08_10 % exp_2013_08_10 - EXPERIMENT similar to 2013_08_09 and the final
% 2013_08_11
% (by Tim Lueth, VLFL-Lib, 2013-AUG-10 as class: EXPERIMENTS)
%
% To curve a 2D contour on a spherical surface, we need
% a) auxiliary surface points inside of the contour
% b) auxiliary contour points on the contour to follow the curve
% c) Delaunay triangulation of the contour surface!
% d) Transformation of the vertices
% (Status of: 2013-08-11)
%
% exp_2013_08_10
%
sofrd(r,d)- returns the minimal auxiliary point distance on a circular curved contour
sofrd(r,d) % sofrd(r,d) - returns the minimal auxiliary point distance on a circular curved contour
% (by Tim Lueth, VLFL-Lib, 2013-AUG-09 as class: ANALYTICAL GEOMETRY)
%
% similar to nofrd. Required for generation grids or auxiliary points on
% a contour or surface (Status of: 2017-01-02)
%
% See also: nofrd, dofn, phiofsr
%
% s=sofrd(r,[d])
% === INPUT PARAMETERS ===
% r: Radius
% d: particle size (default 0.025)
% === OUTPUT RESULTS ======
% s: maximial step size
%
VLFLspherecurvedGPL(GPL,R,CEL)- returns a sphere curved (3D) contoured surface grid (2D)
VLFLspherecurvedGPL(GPL,R,CEL) % VLFLspherecurvedGPL(GPL,R,CEL) - returns a sphere curved (3D) contoured
% surface grid (2D)
% (by Tim Lueth, VLFL-Lib, 2013-AUG-09 as class: ANALYTICAL GEOMETRY)
%
% [VL,FL,CL]=VLFLspherecurvedGPL(GPL,R,CEL)
% === INPUT PARAMETERS ===
% GPL: Grid point list in 2D (x z)
% R: Radius (-x)
% CEL: Contour edge list rel. to GPL
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% CL: Contour vertex list
%
GPLauxgridpointsCL(CL,dx,dy)- returns for a given 2D contour point list auxiliary points to define a plane surface
GPLauxgridpointsCL(CL,dx,dy) % GPLauxgridpointsCL(CL,dx,dy) - returns for a given 2D contour point list auxiliary points to define a plane surface
% (by Tim Lueth, VLFL-Lib, 2013-AUG-09 as class: AUXILIARY PROCEDURES)
%
% The fnctn is based on a cartesian meshgrid that us reshaped to form a
% new points list. The fnctn uses insideC to generate the final index
% list (Status of: 2017-03-27)
%
% See also: RLaddauxpoints, RLdelauxpoints, PLELaddauxpoints,
% GPLauxgridpointsPLEL
%
% [GPL,k]=GPLauxgridpointsCL(CL,dx,dy)
% === INPUT PARAMETERS ===
% CL: Contour list 2D [x y]
% dx: Maximum auxiliary points in x
% dy: Maximum auxiliary points in y
% === OUTPUT RESULTS ======
% GPL: Grid point list
% k: index whether k is inside or outside
%
% EXAMPLE: Generate auxiliary points for a circle
% RL=PLcircle(20);
% pplot (RL','bo-'); view (0,90); hold on; axis equal; axis auto;
% [GPL,k]=GPLauxgridpointsCL (RL,4,4);
% pplot (GPL(k==0,:)', 'b*'); % Already part of Contour
% pplot (GPL(k==1,:)', 'g*'); % Inside of Contour
% pplot (GPL(k==-1,:)','r*'); % Outside of Contour
%
exp_2013_08_09- Experiment to curve a 2D contour on a spherical surface
exp_2013_08_09 % exp_2013_08_09 - Experiment to curve a 2D contour on a spherical surface
% (by Tim Lueth, VLFL-Lib, 2013-AUG-09 as class: EXPERIMENTS)
%
% To curve a 2D contour on a spherical surface, we need
% a) auxiliary points inside of the contour
% b) auxiliary points on the contour to follow the curve
% c) Delaunay triangulation inside the contour!
% d) Transformation of the vertices
% (Status of: 2013-08-09)
%
% exp_2013_08_09
%
exp_2013_08_08- Experiment to show the effect of bending a surface only by contour bending
exp_2013_08_08 % exp_2013_08_08 - Experiment to show the effect of bending a surface
% only by contour bending
% (by Tim Lueth, VLFL-Lib, 2013-AUG-08 as class: EXPERIMENTS)
%
% It is not sufficient to bend a surface only by contour bending (Status
% of: 2013-08-09)
%
% exp_2013_08_08
%
exp_2013_08_07- EXPERIMENT to check what happens if two penetrating solids were used for Delaunay triangulation
exp_2013_08_07 % exp_2013_08_07 - EXPERIMENT to check what happens if two penetrating
% solids were used for Delaunay triangulation
% (by Tim Lueth, , 2013-AUG-15)
%
% dt=exp_2013_08_07
% === OUTPUT RESULTS ======
% dt: data type Delaunay
%
RLdelauxpoints(RL)- deletes supporting points of an open 2D contour to generate staight lines
RLdelauxpoints(RL) % RLdelauxpoints(RL) - deletes supporting points of an open 2D contour to generate staight lines
% (by Tim Lueth, VLFL-Lib, 2013-AUG-07 as class: AUXILIARY PROCEDURES)
%
% This fnctn works ONLY IN 2D! since only the z coordinate of the cross
% product is evaluated and used for the decision (Status of: 2017-03-27)
%
% See also: RLaddauxpoints, GPLauxgridpointsCL, PLELaddauxpoints,
% GPLauxgridpointsPLEL
%
% [RL,i]=RLdelauxpoints(RL)
% === INPUT PARAMETERS ===
% RL: Open 2D contour list
% === OUTPUT RESULTS ======
% RL: Open 2D contour list
% i: index list of the original contour list
%
% EXAMPLE: Insert and delte auxiliary points into a simple contour
% b=10; h=50; RL=[ 0 0;b 0;b h; 0 h];
% RL=RLaddauxpoints (RL,8);
% RL=RLdelauxpoints (RL,8);
%
RLaddauxpoints(RL,d)- add supporting points to an open 2D contour to guarantee a specified points distance
RLaddauxpoints(RL,d) % RLaddauxpoints(RL,d) - add supporting points to an open 2D contour to guarantee a specified points distance
% (by Tim Lueth, VLFL-Lib, 2013-AUG-07 as class: AUXILIARY PROCEDURES)
%
% This fnctns works also with 3D contours, i.e. Vertex List (Status of:
% 2014-12-26)
%
% See also: RLdelauxpoints, GPLauxgridpointsCL, PLELaddauxpoints,
% GPLauxgridpointsPLEL
%
% RL=RLaddauxpoints(RL,d)
% === INPUT PARAMETERS ===
% RL: Open 2D contour list
% d: maximum distance between two points
% === OUTPUT RESULTS ======
% RL: Open 2D contour list
%
% EXAMPLE: Insert auxiliary points into a simple contour
% b=10; h=50; RL=[ 0 0;b 0;b h; 0 h];
% RL=RLaddauxpoints (RL,8);
%
exp_2013_08_06a- Experiment for analyzing different spherical bendings
exp_2013_08_06a % exp_2013_08_06a - Experiment for analyzing different spherical bendings
% (by Tim Lueth, VLFL-Lib, 2013-AUG-06 as class: EXPERIMENTS)
%
% exp_2013_08_06a
%
RLcurvature(RL,C,n0)- returns a circular bended closed contour
RLcurvature(RL,C,n0) % RLcurvature(RL,C,n0) - returns a circular bended closed contour
% (by Tim Lueth, VLFL-Lib, 2013-AUG-06 as class: ANALYTICAL GEOMETRY)
%
% This is a procedure for bending of planar parts on to a spherical
% surface. The neutral fiber is x=0! All x> will be streched, all x< will
% be compressed fir R<0 and vice versa. (Status of: 2013-08-06)
%
% [CL,alpha]=RLcurvature(RL,C,[n0])
% === INPUT PARAMETERS ===
% RL: Radius List (r z)
% C: [R z] of circle center
% n0: 0=neutral fiber at 0; else Rmin
% === OUTPUT RESULTS ======
% CL: circular bended radius list
% alpha: maximum bending angle
%
exp_2013_08_06 (RL,C,n0)- EXPERIMENT to bend a girder contour on a shperical surface
exp_2013_08_06 (RL,C,n0) % exp_2013_08_06 (RL,C,n0) - EXPERIMENT to bend a girder contour on a
% shperical surface
% (by Tim Lueth, VLFL-Lib, 2013-AUG-06 as class: EXPERIMENTS)
%
% exp_2013_08_06(RL,C,[n0])
% === INPUT PARAMETERS ===
% RL: Radius List
% C: Center of the bending circle
% n0: '0' for neutral fiber
%
% EXAMPLE: show a bended girder
% app_2012_11_09([]);
% RL=[ 0 0;10 0;10 50; 0 50];
% exp_2013_08_06 (RL,[-50 00]);
%
SGstackn(SG,n,dz)- returns stacked solid geometries
SGstackn(SG,n,dz) % SGstackn(SG,n,dz) - returns stacked solid geometries
% (by Tim Lueth, VLFL-Lib, 2013-AUG-04 as class: SYNTHESIZING PROCEDURES)
%
% SGN=SGstackn(SG,n,[dz])
% === INPUT PARAMETERS ===
% SG: Solid geometry
% n: number
% dz: distance in z; default is 1mm
% === OUTPUT RESULTS ======
% SGN: Stacked solid geometries
%
SGarrangeSGC(C,Vol3D,Dist3D)- arranges all parts of a SG container
SGarrangeSGC(C,Vol3D,Dist3D) % SGarrangeSGC(C,Vol3D,Dist3D) - arranges all parts of a SG container
% (by Tim Lueth, VLFL-Lib, 2013-AUG-04 as class: SYNTHESIZING PROCEDURES)
%
% To arrange a collection of solid geometries (VL/FL) within a 3D
% printing volume, the fnctn SGCaddSG is first used to collect all SG
% into a SG container. This fnctn SGofSGC is used to arrange the parts of
% the solid geometry container part by part, row by row, layer by layer
% within the printing volume.
% See also: SGCaddSG, SGCaddSGn (Status of: 2016-12-27)
%
% See also: SGboxing, SGpatternXYZ, SGcopyrotZ, SGarrangeSG, SGCaddSGn,
% SGCaddSG
%
% SG=SGarrangeSGC(C,[Vol3D,Dist3D])
% === INPUT PARAMETERS ===
% C: Solid Geometry container (see SGCaddSG)
% Vol3D: 3D printing volume (default: [200 200 250])
% Dist3D: Distance between parts (default: [1 1 1])
% === OUTPUT RESULTS ======
% SG: Solid geometry
%
% EXAMPLE: Arrange 50 boxes within a 3D volume
% A=SGbox ([10,10,10])
% C=SGCaddSGn ([],A,50);
% B=SGofSGC(C,[100 100 100]);
% SGplot(B)
%
exp_2013_08_04- EXPERIMENT that generates a 4-bar-linkage for the GTK 2013
exp_2013_08_04 % exp_2013_08_04 - EXPERIMENT that generates a 4-bar-linkage for the GTK
% 2013
% (by Tim Lueth, VLFL-Lib, 2013-AUG-04 as class: EXPERIMENTS)
%
% This experiment is a copy of exp_2013_07_18, but the layout generation
% is automated.
% The result is a gift for all participants of the GTK-2013 Ilmenau by
% Tim Lueth and Franz Irlinger (Status of: 2013-08-04)
%
% SG4Bar=exp_2013_08_04
% === OUTPUT RESULTS ======
% SG4Bar:
%
exp_2013_07_29(Hb,Rb,Dw,Rf,Hf,m,F)- EXPERIMENT to generate a m-arm snapper with a specified bending force
exp_2013_07_29(Hb,Rb,Dw,Rf,Hf,m,F) % exp_2013_07_29(Hb,Rb,Dw,Rf,Hf,m,F) - EXPERIMENT to generate a m-arm
% snapper with a specified bending force
% (by Tim Lueth, VLFL-Lib, 2013-JUL-29 as class: MODELING PROCEDURES)
%
% [VL,FL]=exp_2013_07_29([Hb,Rb,Dw,Rf,Hf,m,F])
% === INPUT PARAMETERS ===
% Hb: Height of the bore
% Rb: Radius of the bore
% Dw: wall thickness of the snap; default 1
% Rf: Radius of the flange; default Rb+Dw
% Hf: Height of the flange; default Dw
% m: number of hooks; default 6
% F: Force of a Hook
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: exp_2013_07_29 (20,5,[],7,[],3,10);
%
VLFLsnaprivet(Hb,Rb,Dw,Rf,Hf,m,F)- returns the solid geometry (VL,FL) of a male snap rivet push pin with a speficied opening force
VLFLsnaprivet(Hb,Rb,Dw,Rf,Hf,m,F) % VLFLsnaprivet(Hb,Rb,Dw,Rf,Hf,m,F) - returns the solid geometry (VL,FL) of a male snap rivet push pin with a speficied opening force
% (by Tim Lueth, VLFL-Lib, 2013-JUL-29 as class: MODELING PROCEDURES)
%
% Originally exp_2013_07_29, this is a useful procedure for mounting
% mechanims by rivets. (Status of: 2017-02-13)
%
% See also: VLFLbox, VLFLring, VLFLdome, VLFLhemisphere, VLFLpost,
% VLFLcap, VLFLcone, VLFLellipse1, VLFLellipse2, VLFLellipse3, VLFLyarn,
% VLFLweave, VLFLtext, VLFLexpboard, VLFLcreateframe, VLFLcreateblock,
% VLFLcreatecross
%
% [VL,FL]=VLFLsnaprivet([Hb,Rb,Dw,Rf,Hf,m,F])
% === INPUT PARAMETERS ===
% Hb: Height of the bore
% Rb: Radius of the bore
% Dw: wall thickness of the snap; default 1
% Rf: Radius of the flange; default Rb+Dw
% Hf: Height of the flange; default Dw
% m: number of hooks; default 6
% F: Force of a Hook
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: VLFLsnaprivet (20,5,[],7,[],3,10);
%
sofbendinggirder(l,h,b,F,E,Slim)- returns the expected bending of a girder/cantilever
sofbendinggirder(l,h,b,F,E,Slim) % sofbendinggirder(l,h,b,F,E,Slim) - returns the expected bending of a girder/cantilever
% (by Tim Lueth, VLFL-Lib, 2013-JUL-27 as class: MECHANICAL PROCEDURES)
%
% See also: rofcircbend, lofbendinggirder
%
% [s,alpha,Smax]=sofbendinggirder(l,h,[b,F,E,Slim])
% === INPUT PARAMETERS ===
% l: length of the girder/cantilever
% h: height of the girder/cantilever
% b: width of the girder/cantilever
% F: Applied force at the end of the girder/cantilever
% E: E modulus of material
% Slim: Bending stress limit of material
% === OUTPUT RESULTS ======
% s: estimated bending of the girder/cantilever
% alpha: resulting bending angle of the girder/cantilever
% Smax: estimated bending stress at the fixed side
%
lofbendinggirder(h,b,s,F,E,Slim)- returns the length of a bended girder
lofbendinggirder(h,b,s,F,E,Slim) % lofbendinggirder(h,b,s,F,E,Slim) - returns the length of a bended girder
% (by Tim Lueth, VLFL-Lib, 2013-JUL-26 as class: MECHANICAL PROCEDURES)
%
% See also: rofcircbend, sofbendinggirder
%
% [l,alpha,Smax]=lofbendinggirder(h,[b,s,F,E,Slim])
% === INPUT PARAMETERS ===
% h: height of the bended girder
% b: width of the bended girder; default h
% s: bending distance; default h
% F: Force to bend distance s; default 10 N
% E: E modulus default 1200 MPa (Polyamid PA12)
% Slim: Limit of bendigg stress
% === OUTPUT RESULTS ======
% l: length of a bended girder
% alpha: bending angle
% Smax: bending stress
%
exp_2013_07_22 (D,H,B)- EXPERIMENT generating a support structure for 3D FDM printers
exp_2013_07_22 (D,H,B) % exp_2013_07_22 (D,H,B) - EXPERIMENT generating a support structure for
% 3D FDM printers
% (by Tim Lueth, VLFL-Lib, 2013-JUL-22 as class: MODELING PROCEDURES)
%
% exp_2013_07_22([D,H,B])
% === INPUT PARAMETERS ===
% D: Distance between supporting pillar; default 10
% H: Height of the structure; default 40;
% B: Diameter of the cuboid pillar
%
exp_2013_07_20-
exp_2013_07_20 % exp_2013_07_20 -
% (by Tim Lueth, VLFL-Lib, 2013-JUL-20 as class: EXPERIMENTS)
%
% exp_2013_07_20
%
exp_2013_07_19- EXPERIMENT to generate test solids for calibration
exp_2013_07_19 % exp_2013_07_19 - EXPERIMENT to generate test solids for calibration
% (by Tim Lueth, VLFL-Lib, 2013-JUL-19 as class: EXPERIMENTS)
%
% That test bodies were required, since during the European heat wave in
% July 2013, the SLS Formiga 100 an MIMED/TUM was unable to print
% reproducible solids anymore (Status of: 2013-08-02)
%
% exp_2013_07_19
%
exp_2013_07_18- EXPERIMENT for the GTK-2013 Ilmenau
exp_2013_07_18 % exp_2013_07_18 - EXPERIMENT for the GTK-2013 Ilmenau
% (by Tim Lueth, VLFL-Lib, 2013-JUL-18 as class: EXPERIMENTS)
%
% This is a gift for all participants of the GTK-2013 Ilmenau by Tim
% Lueth and Franz Irlinger (Status of: 2013-08-02)
%
% exp_2013_07_18
%
VLFLofBB(BB)- return VL and FL for solid related to a bounding box
VLFLofBB(BB) % VLFLofBB(BB) - return VL and FL for solid related to a bounding box
% (by Tim Lueth, NAV-Lib, 2013-JUL-17 as class: MODELING PROCEDURES)
%
% This fnctn is described in chapter 2 of the article collection of Tim
% Lueth and Franz Irlinger on the automatic construction of 3D printable
% mechanisms (Status of: 2017-01-05)
%
% See also: BBiscollofVL, BBofVL, CPLofBB, SGofBB, outboundingbox, BBofSG
%
% [VL,FL]=VLFLofBB(BB)
% === INPUT PARAMETERS ===
% BB: Bounding box [xmin xmax ymin ymax zmin zmax]
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
BBofVL(VL)- returns the limits of the bound box
BBofVL(VL) % BBofVL(VL) - returns the limits of the bound box
% (by Tim Lueth, VLFL-Lib, 2013-JUL-17 as class: AUXILIARY PROCEDURES)
%
% returns a vector [xmin xmax ymin ymax zmin zmax]. It works not only for
% vertex lists [nx3] but also for point lists (nx2) and closed polygon
% lists [nx2] (Status of: 2017-01-05)
%
% See also: BBiscollofVL, CPLofBB, SGofBB, VLFLofBB, outboundingbox,
% BBofSG
%
% bb=BBofVL(VL)
% === INPUT PARAMETERS ===
% VL: Vertex list, Point List, Closed Polygon List
% === OUTPUT RESULTS ======
% bb: [xmin xmax ymin ymax zmin zmax]
%
% EXAMPLE: BBofVL(CPLsample(7))
%
VLFLrotsymRLCL(RL,CL)- returns a solid geometry from of a radius-z list and a contour list
VLFLrotsymRLCL(RL,CL) % VLFLrotsymRLCL(RL,CL) - returns a solid geometry from of a radius-z
% list and a contour list
% (by Tim Lueth, VLFL-Lib, 2013-JUL-17 as class: MODELING PROCEDURES)
%
% This procedure is described in chapter 2 of the article collection of
% Tim Lueth and Franz Irlinger on the automatic construction of 3D
% printable mechanisms. If PLcircseg (R,n) is used to generate the
% contour list, make sure that the radius R=1 in PLcircseg. (Status of:
% 2013-08-06)
%
% [VL,FL]=VLFLrotsymRLCL(RL,CL)
% === INPUT PARAMETERS ===
% RL: Radius list (r z)
% CL: Contour list (x y)
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
VLFLhollowsnapaxle(R,RF,H,W,HF,n,m)- generates a slotted hollow snap axle
VLFLhollowsnapaxle(R,RF,H,W,HF,n,m) % VLFLhollowsnapaxle(R,RF,H,W,HF,n,m) - generates a slotted hollow snap axle
% (by Tim Lueth, VLFL-Lib, 2013-JUL-17 as class: MODELING PROCEDURES)
%
% This fnctn is described in chapter 2 of the article collection of Tim
% Lueth and Franz Irlinger on the automatic construction of 3D printable
% mechanisms (Status of: 2016-12-28)
%
% See also: VLFLsnapfit, VLFLshaft, VLFLcat, TofDPhiH, VLtransT,
% VLFLspacer, VLFLbolt, VLFLlinkage, VLFLofPLz, VLFLwriteSTL,
% VLFLofPLELz, VLFLplot
%
% [VL,FL]=VLFLhollowsnapaxle(R,RF,H,W,HF,n,m)
% === INPUT PARAMETERS ===
% R: Radius of bore
% RF: Radius of flange
% H: Height of Bore
% W: Width of Snapper wall
% HF: Height of flange and snap
% n: number of facets
% m: number of hooks
% === OUTPUT RESULTS ======
% VL: Vetex list
% FL: Facet list
%
exp_2013_07_17(Hb,Rb,Dw,Rf,Hf,m)- EXPERIMENT to generate a 4 arm snapper
exp_2013_07_17(Hb,Rb,Dw,Rf,Hf,m) % exp_2013_07_17(Hb,Rb,Dw,Rf,Hf,m) - EXPERIMENT to generate a 4 arm
% snapper
% (by Tim Lueth, VLFL-Lib, 2013-JUL-16 as class: MODELING PROCEDURES)
%
% [VL,FL]=exp_2013_07_17([Hb,Rb,Dw,Rf,Hf,m])
% === INPUT PARAMETERS ===
% Hb: Height of the bore
% Rb: Radius of the bore
% Dw: wall thickness of the snap; default 1
% Rf: Radius of the flange; default Rb+Dw
% Hf: Height of the flange; default Dw
% m: number of hooks; default 6
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: exp_2013_07_17 (20,5,[],7,[],10);
%
exp_2013_07_16- EXPERIMENT to generate different slotted snap axle
exp_2013_07_16 % exp_2013_07_16 - EXPERIMENT to generate different slotted snap axle
% (by Tim Lueth, VLFL-Lib, 2013-JUL-16 as class: EXPERIMENTS)
%
% This procedure is described in chapter 2 of the article collection of
% Tim Lueth and Franz Irlinger on the automatic construction of 3D
% printable mechanisms (Status of: 2013-08-02)
%
% exp_2013_07_16
%
PLcircseg(R,n,phiA,phiB,Ry)- returns a PL for a circle segment
PLcircseg(R,n,phiA,phiB,Ry) % PLcircseg(R,n,phiA,phiB,Ry) - returns a PL for a circle segment
% (by Tim Lueth, VLFL-Lib, 2013-JUL-16 as class: ANALYTICAL GEOMETRY)
%
% This fnctn is described in chapter 2 of the article collection of Tim
% Lueth and Franz Irlinger on the automatic construction of 3D printable
% mechanisms (Status of: 2017-01-05)
%
% See also: PLcircle, PLevolvente, PLgear, PLhelix, PLkidney, PLrand,
% PLspiral, PLsquare, PLstar
%
% PL=PLcircseg(R,[n,phiA,phiB,Ry])
% === INPUT PARAMETERS ===
% R: Radius
% n: number of auxiliary points
% phiA: start angle
% phiB: end angle
% Ry: Radius in y, default is R
% === OUTPUT RESULTS ======
% PL: Point list n * 2 [x y]
%
% EXAMPLE: PL=PLcircseg (100,80,-pi/2,+pi);
%
SGCpack(SG,B,n)- packs several solids side by side
SGCpack(SG,B,n) % SGCpack(SG,B,n) - packs several solids side by side
% (by Tim Lueth, VLFL-Lib, 2013-JUL-16 as class: MODELING PROCEDURES)
%
% Arranges several individual solids side by side to prepare a joint 3D
% print job (Status of: 2013-07-16)
%
% SG=SGCpack(SG,B,[n])
% === INPUT PARAMETERS ===
% SG: solid geometry collector, could be empty
% B: solid (VL,FL)
% n: number of added parts
% === OUTPUT RESULTS ======
% SG: solid geometry collector
%
% EXAMPLE: Generate 10 Boxes in a row for 3D print
% A=SGbox ([10 10 20]); B=SGbox ([10 10 10]);
% C=SGCpack ([],A,3); C=SGCpack (C,B,2);
% SGplot (C), show
%
exp_2013_07_15- Experiment for evaluation the fitting of different snap-fit sleeve hooks
exp_2013_07_15 % exp_2013_07_15 - Experiment for evaluation the fitting of different
% snap-fit sleeve hooks
% (by Tim Lueth, VLFL-Lib, 2013-JUL-15 as class: MODELING PROCEDURES)
%
% This experiment is part of chapter 2 of book on generation
% solid models of mechanisms for 3D printing/ (Status of: 2013-07-16)
%
% exp_2013_07_15
%
VLFLsnapfit(RI,RA,D,Hf,H,sh,Hh)- returns VL and FL of a snapping hollow axle
VLFLsnapfit(RI,RA,D,Hf,H,sh,Hh) % VLFLsnapfit(RI,RA,D,Hf,H,sh,Hh) - returns VL and FL of a snapping hollow axle
% (by Tim Lueth, VLFL-Lib, 2013-JUL-15 as class: MODELING PROCEDURES)
%
% This fnctn is described in chapter 2 of the article collection of Tim
% Lueth and Franz Irlinger on the automatic construction of 3D printable
% mechanisms (Status of: 2016-12-28)
%
% See also: VLFLshaft, VLFLhollowsnapaxle, VLFLcat, TofDPhiH, VLtransT,
% VLFLspacer, VLFLbolt, VLFLlinkage, VLFLofPLz, VLFLwriteSTL,
% VLFLofPLELz, VLFLplot
%
% [VL,FLW]=VLFLsnapfit(RI,RA,D,Hf,H,sh,Hh)
% === INPUT PARAMETERS ===
% RI: Radius of the bore
% RA: Radius of the flange
% D: Width of the axle
% Hf: Height of the flange
% H: Height of the bore
% sh: size of the hook
% Hh: height of the hook
% === OUTPUT RESULTS ======
% VL: Vertex list
% FLW: Facet list
%
exp_2013_07_14- EXPERIMENT to develop the function VLFLsnapfit
exp_2013_07_14 % exp_2013_07_14 - EXPERIMENT to develop the fnctn VLFLsnapfit
% (by Tim Lueth, VLFL-Lib, 2013-JUL-14 as class: EXPERIMENTS)
%
% exp_2013_07_14
%
VLFLrotsymRLn(RL,n)- returns a solid geometry from of a radius-z list
VLFLrotsymRLn(RL,n) % VLFLrotsymRLn(RL,n) - returns a solid geometry from of a radius-z list
% (by Tim Lueth, VLFL-Lib, 2013-JUL-13 as class: MODELING PROCEDURES)
%
% [VL,FL,FLN]=VLFLrotsymRLn(RL,[n])
% === INPUT PARAMETERS ===
% RL: Radius-Z List
% n: number of edges of the prismatic cross section
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list (FLU;FLO;FLN)
% FLN: Facet list of the wall
%
VLFLshaft(R,h,n)- returns VL and FL of a solid axle
VLFLshaft(R,h,n) % VLFLshaft(R,h,n) - returns VL and FL of a solid axle
% (by Tim Lueth, VLFL-Lib, 2013-JUL-13 as class: MODELING PROCEDURES)
%
% This fnctn is described in chapter 2 of the article collection of Tim
% Lueth and Franz Irlinger on the automatic construction of 3D printable
% mechanisms (Status of: 2016-12-28)
%
% See also: VLFLsnapfit, VLFLhollowsnapaxle, VLFLcat, TofDPhiH, VLtransT,
% VLFLspacer, VLFLbolt, VLFLlinkage, VLFLofPLz, VLFLwriteSTL,
% VLFLofPLELz, VLFLplot
%
% [VL,FL]=VLFLshaft(R,h,n)
% === INPUT PARAMETERS ===
% R: Radius
% h: Height
% n: number of edges
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
exp_2013_07_13- EXPERIMENT to test VLFLrotsymRLn
exp_2013_07_13 % exp_2013_07_13 - EXPERIMENT to test VLFLrotsymRLn
% (by Tim Lueth, VLFL-Lib, 2013-JUL-13 as class: EXPERIMENTS)
%
% Generates different Radius-Z-Lists (Status of: 2013-08-02)
%
% exp_2013_07_13
%
textT (T,TStr,c,s)- drawn a text at the position of a HT matrix
textT (T,TStr,c,s) % textT (T,TStr,c,s) - drawn a text at the position of a HT matrix
% (by Tim Lueth, VLFL-Lib, 2013-JUN-16 as class: ANALYTICAL GEOMETRY)
%
% uses only the translation vector of T = T(1:3,4);
% (Status of: 2017-06-05)
%
% See also: textT, textP, textVL, textCVL
%
% textT(T,TStr,[c,s])
% === INPUT PARAMETERS ===
% T: T matrix
% TStr: Text string
% c: color
% s: font size
%
exp_2013_06_16(PL,silent)- returns the distance of a point to the circle trough 3 other points
exp_2013_06_16(PL,silent) % exp_2013_06_16(PL,silent) - returns the distance of a point to the
% circle trough 3 other points
% (by Tim Lueth, 4BAR-Lib, 2013-JUN-16 as class: EXPERIMENTS)
%
% For 4 given points, this procedure calculates the center and radius of
% a circle trough p2, p3, and p4. Furthermore it returns the shortest
% distance of p1 to the circle (Status of: 2013-06-18)
%
% [d2,d,c2]=exp_2013_06_16([PL,silent])
% === INPUT PARAMETERS ===
% PL: List of 4 points p1, p2, p3, p4
% silent: true => no graphical output
% === OUTPUT RESULTS ======
% d2: Distance between p1 and the circle trough p2, p3, p4
% d: Radius of the circle trough p2, p3, p4
% c2: Center point of the circle trough p2, p3, p4
%
exp_2013_06_15 (a)- Experiment 4 Pose für eine Koppel zur Berechnung eines Punktes relativ zur Koppel und des Gestellpunkts
exp_2013_06_15 (a) %% PUBLISHABLE EXP_2013_06_15 EXPERIMENT 4 POSE FÜR EINE KOPPEL ZUR BERECHNUNG EINES PUNKTES RELATIV ZUR KOPPEL UND DES GESTELLPUNKTS
% (by Tim Lueth, VLFL-Lib, 2013-JUN-16 as class: EXPERIMENTS)

%%

% exp_2013_06_15 (a) - Experiment 4 Pose für eine Koppel zur Berechnung eines Punktes relativ zur Koppel und des Gestellpunkts
% (by Tim Lueth, VLFL-Lib, 2013-JUN-16 as class: EXPERIMENTS)
%
% 4 Posen Synthese (Status of: 2016-12-28)
%
% See also: exp_2013_06_16, fourbarlinkage
%
% exp_2013_06_15([a])
% === INPUT PARAMETERS ===
% a: Distance from Koppel Frame as limitation for the search
%
SGClayout(ST,LayX,LayY)- returns a modified arranged solid table
SGClayout(ST,LayX,LayY) % SGClayout(ST,LayX,LayY) - returns a modified arranged solid table
% (by Tim Lueth, VLFL-Lib, 2013-MAI-12 as class: ANALYTICAL GEOMETRY)
%
% A solid table is part of a solid geometry container. In contains of
% rows with an index to the geometry, and the size of the geometry (n x
% 4) matrix: [Index sx sy sz] (Status of: 2013-05-14)
%
% [STN,ST,UX,UY,A]=SGClayout(ST,LayX,LayY)
% === INPUT PARAMETERS ===
% ST: Solid Table List
% LayX: Layout dimension in X
% LayY: Layout dimension in Y
% === OUTPUT RESULTS ======
% STN: Sorted table list that fit in the layout
% ST: Sorted table list of the parts that did not fit into the layout
% UX: Used rectangle x dimension
% UY: Used rectangle y dimension
% A: Percentage of use
%
exp_2013_05_11- generates a container for a set of solid geometries
exp_2013_05_11 % exp_2013_05_11 - generates a container for a set of solid geometries
% (by Tim Lueth, VLFL-Lib, 2013-MAI-10 as class: EXPERIMENTS)
%
% This experiment shows how a set of boxes could be arranged on a given
% rectangle area to unused area (Status of: 2013-05-12)
%
% C=exp_2013_05_11
% === OUTPUT RESULTS ======
% C: Container including all solid geometries
%
SGboard(x,y,h,nx,ny)- returns the solid geometry of a (raster) board
SGboard(x,y,h,nx,ny) % SGboard(x,y,h,nx,ny) - returns the solid geometry of a (raster) board
% (by Tim Lueth, VLFL-Lib, 2013-MAI-10 as class: MODELING PROCEDURES)
%
% This procedure is a good example, how a mathematical correct model of a
% raster board has much more vertices and facets than a set of intruding
% bars generating exactly the same structure. Construction such a raster
% board using wooden bar, would me more related to the simple description
% (Status of: 2013-05-10)
%
% B=SGboard(x,y,h,[nx,ny])
% === INPUT PARAMETERS ===
% x: dimension in x
% y: dimension in y
% h: dimension in z
% nx: number of holes in x; default is 0
% ny: number of holes in y; default is 0
% === OUTPUT RESULTS ======
% B: Solid geometry of the boards
%
% EXAMPLE: Generate a raster board with a raster of about 6 mm
% A=SGboard (40, 20, 1, floor(40/6), floor(20/6) ); app_2012_11_09 (A);
%
SGboxing(SG,wall,slot,stext,ms,ha)- returns a case for boxing a SG model
SGboxing(SG,wall,slot,stext,ms,ha) % SGboxing(SG,wall,slot,stext,ms,ha) - returns a case for boxing a SG model
% (by Tim Lueth, VLFL-Lib, 2013-MAI-10 as class: MODELING PROCEDURES)
%
% See also: SGpacking, SGpatternXYZ, SGcopyrotZ, SGarrangeSG,
% SGarrangeSGC, SGCaddSGn, SGCaddSG
%
% SGB=SGboxing([SG,wall,slot,stext,ms,ha])
% === INPUT PARAMETERS ===
% SG: Solid geometry to be boxed
% wall: Wall thickness; default is 1
% slot: Space between box and enclosed part; default is 1
% stext: Text ontop of box
% ms: size of the square holes in the walls
% ha: 'c', 'l', 'r' for text alignment
% === OUTPUT RESULTS ======
% SGB: Solid geometry of the housing box and cover
%
% EXAMPLE: Just try: SGboxing
% A=SGbox([40 40 10]);
% SGboxing(A,[],[],'\n\nLecture: Automation in Medicine \nContent:
% Surgical Robot Example\nSummer 2015\n(c) Prof. Dr. Tim C.
% Lueth\nTechnische Universität München')
%
exp_2013_05_10(SG,wall,slot)- Experiment generates a box around a solid geometry
exp_2013_05_10(SG,wall,slot) % exp_2013_05_10(SG,wall,slot) - Experiment generates a box around a
% solid geometry
% (by Tim Lueth, VLFL-Lib, 2013-MAI-10 as class: EXPERIMENTS)
%
% SGB=exp_2013_05_10([SG,wall,slot])
% === INPUT PARAMETERS ===
% SG: Solid geometry to be boxed
% wall: Wall thickness; default is 1
% slot: Space between box and enclosed part; default is 1
% === OUTPUT RESULTS ======
% SGB: Solid geometry of the housing box and cover
%
SGcase(S,wall,slot,lr)- returns the solid geometry for a cubic case with cover
SGcase(S,wall,slot,lr) % SGcase(S,wall,slot,lr) - returns the solid geometry for a cubic case
% with cover
% (by Tim Lueth, VLFL-Lib, 2013-MAI-10 as class: MODELING PROCEDURES)
%
% This procedure is useful for covering small parts in a print job by a
% bigger case with a cover. The inner size of the Box is [x-2*wall
% y-2*wall z-3*wall]. (Status of: 2013-05-10)
%
% [SGB,SGC]=SGcase([S,wall,slot,lr])
% === INPUT PARAMETERS ===
% S: Outer size as vector [x y z]
% wall: Wall Thickness; default is 0.7
% slot: Slot distance; default is 0.5 for separation of box and cover
% lr: desired raster size; default is no raster
% === OUTPUT RESULTS ======
% SGB: SG of the Box
% SGC: SG of the Cover
%
exp_2013_05_08- calucates a simple 4bar linkage
exp_2013_05_08 % exp_2013_05_08 - calucates a simple 4bar linkage
% (by Tim Lueth, VLFL-Lib, 2013-MAI-08 as class: MODELING PROCEDURES)
%
% This procedure is generated for the "10 Getriebetagung 2013 in Ilmenau"
% for a paper of Tim Lueth and Franz Irlinger. Both authors want to
% restrengthen the activites of TUM in mechanisms and linkages.
% This version uses screws and nuts. (Status of: 2013-05-08)
%
% exp_2013_05_08
%
% EXAMPLE: Generate a simple 4-bar linkage 60 20 30 70:
% exp_2013_05_08
%
SGscrewnut(D,L,c)- return the solid geometry of a screw or a nut
SGscrewnut(D,L,c) % SGscrewnut(D,L,c) - return the solid geometry of a screw or a nut
% (by Tim Lueth, VLFL-Lib, 2013-MAI-07 as class: MODELING PROCEDURES)
%
% [SG,H,KD]=SGscrewnut(D,L,[c])
% === INPUT PARAMETERS ===
% D: Diameter
% L: Length
% c: 'B' bolt or 'N' nut; default is 'B'
% === OUTPUT RESULTS ======
% SG: Solid geometry
% H: Size of the thread
% KD: Core diameter
%
SGthread(D,L,c,P,u)- generates a screw thread for a bolt or a nut
SGthread(D,L,c,P,u) % SGthread(D,L,c,P,u) - generates a screw thread for a bolt or a nut
% (by Tim Lueth, VLFL-Lib, 2013-APR-30 as class: MODELING PROCEDURES)
%
% This procedure generates a solid geometry for a bold or nut. It is also
% a good example of sweeping a contour along a helix. The procedure was
% modified in June 2015 to create full threads using the procedure SGcut.
% A 5th parameter was added: "Full" means that the tread fills the
% complete length; "Complete" means that all threats are complete and nut
% cutted. (Status of: 2015-06-09)
%
% [SG,H,KD]=SGthread(D,L,[c,P,u])
% === INPUT PARAMETERS ===
% D: Diameter (related to DIN 13)
% L: Length of the thread
% c: 'N' or 'B'; default is 'B'
% P: pitch; default is taken from DIN13
% u: 'F' or 'C; default is 'F'
% === OUTPUT RESULTS ======
% SG: Solid geometry of the thread
% H: Size of the thread
% KD: Core diameter of bold or nut
%
% EXAMPLE: Generate two different
%
VLFLspacer(RA,RI,H)- returns a 2½ D solid geometry of a spacer
VLFLspacer(RA,RI,H) % VLFLspacer(RA,RI,H) - returns a 2½ D solid geometry of a spacer
% (by Tim Lueth, VLFL-Lib, 2013-APR-29 as class: MODELING PROCEDURES)
%
% Tim C. Lueth, Franz Irlinger: "Berechnete Erzeugung von
% dreidimensionalen Oberflächenmodellen im STL-Format aus der
% Beschreibung planarer Mechanismen für die Generative Fertigung durch
% Selektives-Lasersintern [Computational 3D Surface Generation of Planar
% Mechanismus using STL File Format for Generative Manufacturing by
% Selective Laser Sintering]", angenommener Beitrag im Konferenzband 10.
% Kolloquium Getriebetechnik, TU Ilmenau, Sep. 11-13, 2013, pp 1-18.
% (Status of: 2016-12-28)
%
% See also: VLFLsnapfit, VLFLshaft, VLFLhollowsnapaxle, VLFLcat,
% TofDPhiH, VLtransT, VLFLbolt, VLFLlinkage, VLFLofPLz, VLFLwriteSTL,
% VLFLofPLELz, VLFLplot
%
% [VL,FL]=VLFLspacer(RA,RI,H)
% === INPUT PARAMETERS ===
% RA: Outer Radius
% RI: Inner Radius
% H: Height
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
VLFLbolt(R,H)- returns a 2½ D solid geometry of a bolt
VLFLbolt(R,H) % VLFLbolt(R,H) - returns a 2½ D solid geometry of a bolt
% (by Tim Lueth, VLFL-Lib, 2013-APR-29 as class: MODELING PROCEDURES)
%
% Tim C. Lueth, Franz Irlinger: "Berechnete Erzeugung von
% dreidimensionalen Oberflächenmodellen im STL-Format aus der
% Beschreibung planarer Mechanismen für die Generative Fertigung durch
% Selektives-Lasersintern [Computational 3D Surface Generation of Planar
% Mechanismus using STL File Format for Generative Manufacturing by
% Selective Laser Sintering]", angenommener Beitrag im Konferenzband 10.
% Kolloquium Getriebetechnik, TU Ilmenau, Sep. 11-13, 2013, pp 1-18.
% (Status of: 2016-12-28)
%
% See also: VLFLsnapfit, VLFLshaft, VLFLhollowsnapaxle, VLFLcat,
% TofDPhiH, VLtransT, VLFLspacer, VLFLlinkage, VLFLofPLz, VLFLwriteSTL,
% VLFLofPLELz, VLFLplot
%
% [VL,FL]=VLFLbolt(R,H)
% === INPUT PARAMETERS ===
% R: Outer Radius
% H: Height
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
VLFLlinkage(RA,RI,H,D)- returns a 2½ D solid geometry of a linkage
VLFLlinkage(RA,RI,H,D) % VLFLlinkage(RA,RI,H,D) - returns a 2½ D solid geometry of a linkage
% (by Tim Lueth, VLFL-Lib, 2013-APR-29 as class: MODELING PROCEDURES)
%
% Tim C. Lueth, Franz Irlinger: "Berechnete Erzeugung von
% dreidimensionalen Oberflächenmodellen im STL-Format aus der
% Beschreibung planarer Mechanismen für die Generative Fertigung durch
% Selektives-Lasersintern [Computational 3D Surface Generation of Planar
% Mechanismus using STL File Format for Generative Manufacturing by
% Selective Laser Sintering]", angenommener Beitrag im Konferenzband 10.
% Kolloquium Getriebetechnik, TU Ilmenau, Sep. 11-13, 2013, pp 1-18.
% (Status of: 2016-12-28)
%
% See also: VLFLsnapfit, VLFLshaft, VLFLhollowsnapaxle, VLFLcat,
% TofDPhiH, VLtransT, VLFLspacer, VLFLbolt, VLFLofPLz, VLFLwriteSTL,
% VLFLofPLELz, VLFLplot
%
% [VL,FL,PL,EL]=VLFLlinkage(RA,RI,H,D)
% === INPUT PARAMETERS ===
% RA: Outer Radius
% RI: Inner Radius
% H: Height
% D: Distance in X
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% PL: Point list of the contour
% EL: Contour edge list
%
exp_2013_04_29- returns the geometry of a snap-in rivet
exp_2013_04_29 % exp_2013_04_29 - returns the geometry of a snap-in rivet
% (by Tim Lueth, VLFL-Lib, 2013-APR-29 as class: MODELING PROCEDURES)
%
% exp_2013_04_29
%
VLFLofPLELH(PL,EL,H)- returns a 2½ D solid geometry of a contour
VLFLofPLELH(PL,EL,H) % VLFLofPLELH(PL,EL,H) - returns a 2½ D solid geometry of a contour
% (by Tim Lueth, VLFL-Lib, 2013-APR-29 as class: MODELING PROCEDURES)
%
% Basic modeling procedure to generate a 2½ D solid geometry from a given
% outer an inner contour solid (Status of: 2013-04-29)
%
% [SVL,SFL]=VLFLofPLELH(PL,EL,H)
% === INPUT PARAMETERS ===
% PL: Point list in 2D
% EL: Edge list
% H: Height
% === OUTPUT RESULTS ======
% SVL: Vertex list
% SFL: Facet list
%
exp_2013_04_27- calucates a simple 4bar linkage
exp_2013_04_27 % exp_2013_04_27 - calucates a simple 4bar linkage
% (by Tim Lueth, VLFL-Lib, 2013-APR-27 as class: MODELING PROCEDURES)
%
% This procedure is generated for the "10 Getriebetagung 2013 in Ilmenau"
% for a paper of Tim Lueth and Franz Irlinger. Both authors want to
% restrengthen the activites of TUM in mechanisms and linkages. (Status
% of: 2013-04-28)
%
% exp_2013_04_27
%
% EXAMPLE: Generate a simple 4-bar linkage:
% exp_2013_04_27
%
DIN13(M)- returns the DIN-13 table for a metric threads
DIN13(M) % DIN13(M) - returns the DIN-13 table for a metric threads
% (by Tim Lueth, VLFL-Lib, 2013-APR-27 as class: AUXILIARY PROCEDURES)
%
% The table DIN-13 has the following columns. All values are given in
% millimeter
% 1) Metric outer diameter in mm
% 2) Pitch in mm
% 3) Flank length in mm
% 4) Core diameter for bolts
% 5) Core diameter for nuts
% 6) Threat depth for bolts
% 7) Threat depth for nuts (Status of: 2013-08-15)
%
% [M,TL]=DIN13(M)
% === INPUT PARAMETERS ===
% M: metric treat diameter
% === OUTPUT RESULTS ======
% M: M that was used for the table entry
% TL: Table entry for M
%
VLFLviewer(SG,SG.FL,xcol)- Application for opening and viewing STL Files
VLFLviewer(SG,SG.FL,xcol) % VLFLviewer(SG,SG.FL,xcol) - Application for opening and viewing STL
% Files
% (by Tim Lueth, VLFL-Lib, 2013-APR-25 as class: APPLICATION)
%
% The procedure can be compiled as application or used as user interface
% procedure. Called without input parameters, a file reading dialog will
% be opened. There are examples for reading, writing of STL files and
% changing light condition or grid information.
% It should show the potential of Matlab to the company Arburg, Lossburg
% (Status of: 2014-11-16)
%
% [hf,hm,ht,htt]=VLFLviewer([SG,SG.FL,xcol])
% === INPUT PARAMETERS ===
% SG: Vertex list of solid geometry
% SG.FL: Facet list of solid geometry
% xcol:
% === OUTPUT RESULTS ======
% hf: handle to figure
% hm: handle to menu
% ht: handle to toolbar
% htt: handle to button 1
%
% EXAMPLE: GUI with a small cube (0.1 0.1 0.1) in the center:
% VLFLviewer ([]);
%
SGlinkage(R,D,H,RA,D2)- returns the solid geometry of a linkage
SGlinkage(R,D,H,RA,D2) % SGlinkage(R,D,H,RA,D2) - returns the solid geometry of a linkage
% (by Tim Lueth, VLFL-Lib, 2013-APR-25 as class: MODELING PROCEDURES)
%
% This procedure to generate 4-bar linkages was derivated from
% exp_2013_04-23 (Status of: 2014-12-26)
%
% See also: SGcone, SGsphere, SGbox, SGtext
%
% SG=SGlinkage(R,D,H,[RA,D2])
% === INPUT PARAMETERS ===
% R: Radius of the R-joint
% D: Distance between the two R-Joints
% H: Height on z of the linkage
% RA: Radius of the linkage (Default is 1.5 * R)
% D2: Optional Distance in x for a 3rd hole
% === OUTPUT RESULTS ======
% SG: Solid geometry VL/FL
%
% EXAMPLE: Simple educational use:
% SGlinkage
%
PLconvexhull(PL)- returns the convex hull of a 2D point [nx2] list
PLconvexhull(PL) % PLconvexhull(PL) - returns the convex hull of a 2D point [nx2] list
% (by Tim Lueth, VLFL-Lib, 2013-APR-24 as class: AUXILIARY PROCEDURES)
%
% This procedure returns the point list [nx2] of the convex hull and is
% an open PL. The last point and the first point are different. Points on
% straight lines are not removed. (Status of: 2015-10-03)
%
% PHL=PLconvexhull(PL)
% === INPUT PARAMETERS ===
% PL: Single Contour Point List
% === OUTPUT RESULTS ======
% PHL: Convex hull point list
%
exp_2013_04_23- Generates a link for a 4-bar linkage
exp_2013_04_23 % exp_2013_04_23 - Generates a link for a 4-bar linkage
% (by Tim Lueth, VLFL-Lib, 2013-APR-23 as class: SYNTHESIZING PROCEDURES)
%
% This experiment is for educational purpose, and explains step by step
% how to generate a 2 RR-joint linkage that can be used for a 4-bar
% linkage. (Status of: 2013-04-24)
%
% exp_2013_04_23
%
% EXAMPLE: Press Enter to go forwards step by step:
%
VLswapZ(VL)- returns a 2D or 3D point/vertex list, mirrored at the z-Axis
VLswapZ(VL) % VLswapZ(VL) - returns a 2D or 3D point/vertex list, mirrored at the z-Axis
% (by Tim Lueth, VLFL-Lib, 2013-APR-23 as class: AUXILIARY PROCEDURES)
%
% See also: VLswapYZ, VLswapZY, VLswapXY, VLswapYX, VLswapZX, VLswapXZ,
% VLswapX, VLswapY
%
% RVL=VLswapZ(VL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% === OUTPUT RESULTS ======
% RVL: Resulting vertex list
%
VLswapY(VL)- returns a 2D or 3D point/vertex list, mirrored at the y-Axis
VLswapY(VL) % VLswapY(VL) - returns a 2D or 3D point/vertex list, mirrored at the y-Axis
% (by Tim Lueth, VLFL-Lib, 2013-APR-23 as class: AUXILIARY PROCEDURES)
%
% See also: VLswapYZ, VLswapZY, VLswapXY, VLswapYX, VLswapZX, VLswapXZ,
% VLswapX, VLswapZ
%
% RVL=VLswapY(VL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% === OUTPUT RESULTS ======
% RVL: Resulting vertex list
%
VLswapX(VL)- returns a 2D or 3D point/vertex list, mirrored at the x-Axis
VLswapX(VL) % VLswapX(VL) - returns a 2D or 3D point/vertex list, mirrored at the x-Axis
% (by Tim Lueth, VLFL-Lib, 2013-APR-23 as class: AUXILIARY PROCEDURES)
%
% See also: VLswapYZ, VLswapZY, VLswapXY, VLswapYX, VLswapZX, VLswapXZ,
% VLswapY, VLswapZ
%
% RVL=VLswapX(VL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% === OUTPUT RESULTS ======
% RVL: Resulting vertex list
%
PLsquare(X,Y)- returns a 4 point list describing a rectangle in 2D
PLsquare(X,Y) % PLsquare(X,Y) - returns a 4 point list describing a rectangle in 2D
% (by Tim Lueth, VLFL-Lib, 2013-APR-23 as class: MODELING PROCEDURES)
%
% This is a basic point list generation fnctn. See also PLcircle (Status
% of: 2017-01-05)
%
% See also: PLcircle, PLcircseg, PLevolvente, PLgear, PLhelix, PLkidney,
% PLrand, PLspiral, PLstar
%
% PL=PLsquare(X,[Y])
% === INPUT PARAMETERS ===
% X: Dimension in X or [x y]
% Y: Dimension in X, default Y=X or X(2)
% === OUTPUT RESULTS ======
% PL: 2D Point list
%
% EXAMPLE: Generate a simple point list for a rectangle:
% A=PLsquare(20,10);
% pplot (A','b*-',4), view (0,90), axis equal; grid on
%
SGincenter(A,B,gap)- Changes the VL of solid A to be in the center of solid B
SGincenter(A,B,gap) % SGincenter(A,B,gap) - Changes the VL of solid A to be in the center of
% solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGincenter, SGunder, SGontop, SGinfront, SGbehind, SGleft,
% SGright
%
% A=SGincenter(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL centered in solid B
%
SGalignfront(A,B,gap)- Changes the VL of solid A to be front aligned with solid B
SGalignfront(A,B,gap) % SGalignfront(A,B,gap) - Changes the VL of solid A to be front aligned
% with solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGaligntop, SGalignbottom, SGalignfront, SGalignback,
% SGalignleft, SGalignright
%
% A=SGalignfront(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL front aligned with solid B
%
SGalignback(A,B,gap)- Changes the VL of solid A to be back aligned with solid B
SGalignback(A,B,gap) % SGalignback(A,B,gap) - Changes the VL of solid A to be back aligned
% with solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGaligntop, SGalignbottom, SGalignfront, SGalignback,
% SGalignleft, SGalignright
%
% A=SGalignback(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL back aligned with solid B
%
SGbehind(A,B,gap)- Changes the VL of solid A to be behind of solid B
SGbehind(A,B,gap) % SGbehind(A,B,gap) - Changes the VL of solid A to be behind of solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGincenter, SGunder, SGontop, SGinfront, SGbehind, SGleft,
% SGright
%
% A=SGbehind(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL behind of solid B
%
SGinfront(A,B,gap)- Changes the VL of solid A to be infront of solid B
SGinfront(A,B,gap) % SGinfront(A,B,gap) - Changes the VL of solid A to be infront of solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGincenter, SGunder, SGontop, SGinfront, SGbehind, SGleft,
% SGright
%
% A=SGinfront(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL infront of solid B
%
SGleft(A,B,gap)- Changes the VL of solid A that A is left of solid B
SGleft(A,B,gap) % SGleft(A,B,gap) - Changes the VL of solid A that A is left of solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGincenter, SGunder, SGontop, SGinfront, SGbehind, SGleft,
% SGright
%
% A=SGleft(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL ontop of solid B
%
SGright(A,B,gap)- Changes the VL of solid A that A is right of solid B
SGright(A,B,gap) % SGright(A,B,gap) - Changes the VL of solid A that A is right of solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGincenter, SGunder, SGontop, SGinfront, SGbehind, SGleft,
% SGright
%
% A=SGright(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL ontop of solid B
%
SGalignbottom(A,B,gap)- Changes the VL that solid A has the same bottom (min z) edges as solid B
SGalignbottom(A,B,gap) % SGalignbottom(A,B,gap) - Changes the VL that solid A has the same
% bottom (min z) edges as solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGaligntop, SGalignbottom, SGalignfront, SGalignback,
% SGalignleft, SGalignright
%
% A=SGalignbottom(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Gap between A and B, positive means inside; negative outside
% === OUTPUT RESULTS ======
% A: Solid A whose minimal z-Values of VL are the same as of solid B
%
SGaligntop(A,B,gap)- Changes the VL that solid A has the same top (max z) edges as solid B
SGaligntop(A,B,gap) % SGaligntop(A,B,gap) - Changes the VL that solid A has the same top (max
% z) edges as solid B
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: MODELING PROCEDURES)
%
% See also: SGaligntop, SGalignbottom, SGalignfront, SGalignback,
% SGalignleft, SGalignright
%
% A=SGaligntop(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Gap between A and B, positive means inside; negative outside
% === OUTPUT RESULTS ======
% A: Solid A whose maximal z-Values of VL are the same as of solid B
%
exp_2013_04_02- EXPERIMENT to test the spatial relation functions for solid geoemtries
exp_2013_04_02 % exp_2013_04_02 - EXPERIMENT to test the spatial relation fnctns for solid geoemtries
% (by Tim Lueth, VLFL-Lib, 2013-APR-02 as class: EXPERIMENTS)
%
% This Experiment follows exp_2013_01_16 after 2.5 Mopnth break because
% of the SFB 989 preparation. (Status of: 2017-01-04)
%
% [SGB,SGF,SGM]=exp_2013_04_02
% === OUTPUT RESULTS ======
% SGB: Solid Geometry of the Body
% SGF: Solid Geometry of the Fnctn Parts
% SGM: Solid Geometry of the Mounting Parts
%
SGsize(SG)- returns the minimal and maximal value in x, y, z of a SG
SGsize(SG) % SGsize(SG) - returns the minimal and maximal value in x, y, z of a SG
% (by Tim Lueth, VLFL-Lib, 2013-JAN-20 as class: AUXILIARY PROCEDURES)
%
% Uses sizeVL, VLFLconot (Status of: 2017-02-04)
%
% See also: BBiscollofVL, BBofVL, CPLofBB, SGofBB, VLFLofBB,
% outboundingbox, BBofSG, sizeVL
%
% m=SGsize([SG])
% === INPUT PARAMETERS ===
% SG: Solid Geometry, or Cell list of SGs, or separated by comma
% === OUTPUT RESULTS ======
% m: 1 x 6 array (xmin xmax ymin ymax zmin zmax]
%
exp_2013_01_20- EXPERIMENT to automatically genrate a holder for a servo S3156
exp_2013_01_20 % exp_2013_01_20 - EXPERIMENT to automatically genrate a holder for a
% servo S3156
% (by Tim Lueth, VLFL-Lib, 2013-JAN-20 as class: SYNTHESIZING PROCEDURES)
%
% Uses exp_2013_01_16 to generate a solid geometry for the FUTABA servo
% including the axle and the cable. Afterwards calculate the hold using
% the boxing procedure that allows to assemble the part and has an
% opening for the cable.
% Please us the save command in the grahical window to write the STL
% file. (Status of: 2013-01-20)
%
% exp_2013_01_20
%
SGalignleft(A,B,gap)- Changes the VL that solid A has the same left (min x) edges as solid B
SGalignleft(A,B,gap) % SGalignleft(A,B,gap) - Changes the VL that solid A has the same left
% (min x) edges as solid B
% (by Tim Lueth, VLFL-Lib, 2013-JAN-17 as class: MODELING PROCEDURES)
%
% See also: SGaligntop, SGalignbottom, SGalignfront, SGalignback,
% SGalignleft, SGalignright
%
% A=SGalignleft(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Gap between A and B, positive means inside; negative outside
% === OUTPUT RESULTS ======
% A: Solid A whose minimal x-Values of VL are the same as of solid B
%
SGalignright(A,B,gap)- Changes the VL that solid A has the same right (max x) edges as solid B
SGalignright(A,B,gap) % SGalignright(A,B,gap) - Changes the VL that solid A has the same right
% (max x) edges as solid B
% (by Tim Lueth, VLFL-Lib, 2013-JAN-17 as class: MODELING PROCEDURES)
%
% See also: SGaligntop, SGalignbottom, SGalignfront, SGalignback,
% SGalignleft, SGalignright
%
% A=SGalignright(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, positive means inside; negative
% outside
% === OUTPUT RESULTS ======
% A: Solid A whose maximal x-Values of VL are the same as of solid B
%
SGunder(A,B,gap)- Changes the VL of solid A that A is under solid B
SGunder(A,B,gap) % SGunder(A,B,gap) - Changes the VL of solid A that A is under solid B
% (by Tim Lueth, VLFL-Lib, 2013-JAN-17 as class: MODELING PROCEDURES)
%
% See also: SGincenter, SGunder, SGontop, SGinfront, SGbehind, SGleft,
% SGright
%
% A=SGunder(A,[B,gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL under solid B
%
SGontop(A,B,gap)- Changes the VL of solid A that A is ontop of solid B
SGontop(A,B,gap) % SGontop(A,B,gap) - Changes the VL of solid A that A is ontop of solid B
% (by Tim Lueth, VLFL-Lib, 2013-JAN-17 as class: MODELING PROCEDURES)
%
% Beside B as solid geometry, B can also be empty, or a 4x4 HT matrix
% (Status of: 2013-09-17)
%
% See also: SGincenter, SGunder, SGontop, SGinfront, SGbehind, SGleft,
% SGright
%
% A=SGontop(A,B,[gap])
% === INPUT PARAMETERS ===
% A: Solid geometry A
% B: Solid geometry B; can be empty
% gap: Optional gap between A and B, can be negative
% === OUTPUT RESULTS ======
% A: Solid A with VL ontop of solid B
%
SGbox(S,n)- returns soldi geometry of a origin centered box
SGbox(S,n) % SGbox(S,n) - returns soldi geometry of a origin centered box
% (by Tim Lueth, VLFL-Lib, 2013-JAN-17 as class: MODELING PROCEDURES)
%
% See also: SGcone, SGsphere, SGlinkage, SGtext
%
% SG=SGbox(S,[n])
% === INPUT PARAMETERS ===
% S: size vector type [x y z]
% n: numbers of edges; default =4
% === OUTPUT RESULTS ======
% SG: VL / FL of the box
%
% EXAMPLE: A=SGbox([30,20,10]); SGplot(A)
% A=SGbox([10,10,40],40); SGplot(A)
%
maprows(VLA,VLB)- returns index mapping list for two rows list (error free since 2017-04-24)
maprows(VLA,VLB) % maprows(VLA,VLB) - returns index mapping list for two rows list (error free since 2017-04-24)
% (by Tim Lueth, VLFL-Lib, 2013-JAN-16 as class: AUXILIARY PROCEDURES)
%
% indexa = a(indexb)
% indexb = b(indexa)
% If there is a vertex list LB and a facet list flb, then the same facet
% list for different sorted vertex list LA of the same vertices would be:
% lfa = a(flb).
% The procedure uses unique two times, so it makes sense only, if there
% is no idea on the mapping. ATTENTION: WORKS ONLY IF THERE ARE NO DOUBLE
% ENTRIES (Status of: 2017-04-24)
%
% See also: maprows, findVL, reversesortindex
%
% [a,b]=maprows(VLA,VLB)
% === INPUT PARAMETERS ===
% VLA: List A
% VLB: List B
% === OUTPUT RESULTS ======
% a: used to transform index list based on A indices
% b: used to transform index list based on B indices
%
% EXAMPLE: Find the original order for an unsorted list
% AL=ELofn(10); BL=ELunsort(AL); [ai,bi]=maprows(AL,BL); [AL BL ai bi]
% [ BL(ai,:), AL(bi,:)]
%
SGtext(SG,stext,ez,sx,sy,ha)- returns a SG that does fit on the surface on another SG
SGtext(SG,stext,ez,sx,sy,ha) % SGtext(SG,stext,ez,sx,sy,ha) - returns a SG that does fit on the
% surface on another SG
% (by Tim Lueth, VLFL-Lib, 2013-JAN-16 as class: TEXT PROCEDURES)
%
% This procedure allows very convenient to set text string on surfaces of
% solid geometries. (Status of: 2016-12-27)
%
% See also: SGoftext, VLFLtextimage
%
% SGT=SGtext(SG,stext,ez,[sx,sy,ha])
% === INPUT PARAMETERS ===
% SG: Solid Geometry to mount the text
% stext: String to mount
% ez: Normal vector of the union area to mount on
% sx: optional parameter for the size
% sy: size in y
% ha: horizontal alignment (if several lines)
% === OUTPUT RESULTS ======
% SGT: Solid geometry of the text string
%
% EXAMPLE: Create text with or without an existing solid:
% SGtext(SGbox([30,20,1]),sprintf('TL:%s',datestrroman),[0 0 1],30);
% SGtext([],sprintf('TL:%s',datestrroman),[0 -1 0],30);
%
exp_2013_01_16- EXPERIMENT to manually generate geometrical models of a servo motor FUTABA S3156
exp_2013_01_16 % exp_2013_01_16 - EXPERIMENT to manually generate geometrical models of
% a servo motor FUTABA S3156
% (by Tim Lueth, VLFL-Lib, 2013-JAN-15 as class: EXPERIMENTS)
%
% [SGB,SGF,SGM]=exp_2013_01_16
% === OUTPUT RESULTS ======
% SGB:
% SGF:
% SGM:
%
exp_2013_01_15- EXPERIMENT for trying to connect twp solids directly using VLFLcoatPCVL
exp_2013_01_15 % exp_2013_01_15 - EXPERIMENT for trying to connect twp solids directly
% using VLFLcoatPCVL
% (by Tim Lueth, VLFL-Lib, 2013-JAN-15 as class: EXPERIMENTS)
%
% VLFLcoatPCVL is extremely helpful, if two vessels should be connects by
% a pipe coat. If the contours are in the same plane, VLFLcoatPCVL needs
% a exception handling (Status of: 2013-01-15)
%
% exp_2013_01_15
%
VLFLcoatPCVL(VLi)- returns coat and covers for vessel contours
VLFLcoatPCVL(VLi) % VLFLcoatPCVL(VLi) - returns coat and covers for vessel contours
% (by Tim Lueth, VLFL-Lib, 2013-JAN-14 as class: SYNTHESIZING PROCEDURES)
%
% Very powerful 3rd generation procedure to generate 3D structures based
% on several contours. The procedure generates a surface excluding the
% covered contours. A vessel structure is generated.
% 1st Generation: Tim Lueth reinvents analytical geometry
% 2nd Generation: Tim Lueth uses Delaunay triangulation
% 3rd Generation: Tim Lueth understands Delaunay triangulation (Status
% of: 2016-12-27)
%
% See also: TofPCVL, CVLplot
%
% [VLN,FLcoat,varargout]=VLFLcoatPCVL([VLi])
% === INPUT PARAMETERS ===
% VLi: Planar Contour Vertex List, separated: VL1, VL2, VL3 etc.
% === OUTPUT RESULTS ======
% [VL(VLi) - returns coat and covers for vessel contours
% % (by Tim Lueth, VLFL-Lib, 2013-JAN-14 as class: SYNTHESIZING
% PROCEDURES)
% %
% % Very powerful 3rd generation procedure to generate 3D structures
% based
% % on several contours. The procedure generates a surface excluding the
% % covered contours. A vessel structure is generated.
% % 1st Generation: Tim Lueth reinvents analytical geometry
% % 2nd Generation: Tim Lueth uses Delaunay triangulation
% % 3rd Generation: Tim Lueth understands Delaunay triangulation (Status
% % of: 2016-12-27)
% %
% % See also: TofPCVL
% %
% % [VLN,FLcoat,varargout]=VLFLcoatPCVL([VLi])
% % === INPUT PARAMETERS ===
% % VLi: Planar Contour Vertex List, separated: VL1, VL2, VL3 etc.
% % === OUTPUT RESULTS ======
% % [VL(VLi) - returns coat and covers for vessel contours
% % % (by Tim Lueth, VLFL-Lib, 2013-JAN-14 as class: SYNTHESIZING
% % PROCEDURES)
% % %
% % % Very powerful 3rd generation procedure to generate 3D structures
% % based
% % % on several contours. The procedure generates a surface excluding
% the
% % % covered contours. A vessel structure is generated.
% % % 1st Generation: Tim Lueth reinvents analytical geometry
% % % 2nd Generation: Tim Lueth uses Delaunay triangulation
% % % 3rd Generation: Tim Lueth understands Delaunay triangulation
% (Status
% % % of: 2013-01-14)
% % %
% % % [VLN,FLcoat,varargout]=VLFLcoatPCVL([VLi])
% % % === INPUT PARAMETERS ===
% % % VLi: Planar Contour Vertex List, separated: VL1, VL2, VL3 etc.
% % % === OUTPUT RESULTS ======
% % % VLN: Vertex
% % % FLcoat: Facet list of the coat without the covers for VLBA, etc.
% % % varargout: Facet list to cover planar contour VL1, VL2, VL3 etc.
% % %
% % fnctn [VLN,FLcoat,varargout]=VLFLcoatPCVL(varargin)
% % % VLi=varargin{1}]: Vertex
% % [VL(VLi) - returns coat and covers for vessel contours
% % % (by Tim Lueth, VLFL-Lib, 2013-JAN-14 as class: SYNTHESIZING
% % PROCEDURES)
% % %
% % % Very powerful 3rd generation procedure to generate 3D structures
% % based
% % % on several contours. The procedure generates a surface excluding
% the
% % % covered contours. A vessel structure is generated.
% % % 1st Generation: Tim Lueth reinvents analytical geometry
% % % 2nd Generation: Tim Lueth uses Delaunay triangulation
% % % 3rd Generation: Tim Lueth understands Delaunay triangulation
% (Status
% % % of: 2013-01-14)
% % %
% % % [VLN,FLcoat,varargout]=VLFLcoatPCVL([VLi])
% % % === INPUT PARAMETERS ===
% % % VLi: Planar Contour Vertex List, separated: VL1, VL2, VL3 etc.
% % % === OUTPUT RESULTS ======
% % % VLN: Vertex
% % % FLcoat: Facet list of the coat without the covers for VLBA, etc.
% % % varargout: Facet list to cover planar contour VL1, VL2, VL3 etc.
% % %
% % fnctn [VLN,FLcoat,varargout]=VLFLcoatPCVL(varargin)
% % % VLi=varargin{1}]: Facet list of the coat without the covers for
% VLBA,
% % etc.
% % varargout: Facet list to cover planar contour VL1, VL2, VL3 etc.
% %
% fnctn [VLN,FLcoat,varargout]=VLFLcoatPCVL(varargin)
% % VLi=varargin{1}]: Vertex
% [VL(VLi) - returns coat and covers for vessel contours
% % (by Tim Lueth, VLFL-Lib, 2013-JAN-14 as class: SYNTHESIZING
% PROCEDURES)
% %
% % Very powerful 3rd generation procedure to generate 3D structures
% based
% % on several contours. The procedure generates a surface excluding the
% % covered contours. A vessel structure is generated.
% % 1st Generation: Tim Lueth reinvents analytical geometry
% % 2nd Generation: Tim Lueth uses Delaunay triangulation
% % 3rd Generation: Tim Lueth understands Delaunay triangulation (Status
% % of: 2016-12-27)
% %
% % See also: TofPCVL
% %
% % [VLN,FLcoat,varargout]=VLFLcoatPCVL([VLi])
% % === INPUT PARAMETERS ===
% % VLi: Planar Contour Vertex List, separated: VL1, VL2, VL3 etc.
% % === OUTPUT RESULTS ======
% % [VL(VLi) - returns coat and covers for vessel contours
% % % (by Tim Lueth, VLFL-Lib, 2013-JAN-14 as class: SYNTHESIZING
% % PROCEDURES)
% % %
% % % Very powerful 3rd generation procedure to generate 3D structures
% % based
% % % on several contours. The procedure generates a surface excluding
% the
% % % covered contours. A vessel structure is generated.
% % % 1st Generation: Tim Lueth reinvents analytical geometry
% % % 2nd Generation: Tim Lueth uses Delaunay triangulation
% % % 3rd Generation: Tim Lueth understands Delaunay triangulation
% (Status
% % % of: 2013-01-14)
% % %
% % % [VLN,FLcoat,varargout]=VLFLcoatPCVL([VLi])
% % % === INPUT PARAMETERS ===
% % % VLi: Planar Contour Vertex List, separated: VL1, VL2, VL3 etc.
% % % === OUTPUT RESULTS ======
% % % VLN: Vertex
% % % FLcoat: Facet list of the coat without the covers for VLBA, etc.
% % % varargout: Facet list to cover planar contour VL1, VL2, VL3 etc.
% % %
% % fnctn [VLN,FLcoat,varargout]=VLFLcoatPCVL(varargin)
% % % VLi=varargin{1}]: Vertex
% % [VL(VLi) - returns coat and covers for vessel contours
% % % (by Tim Lueth, VLFL-Lib, 2013-JAN-14 as class: SYNTHESIZING
% % PROCEDURES)
% % %
% % % Very powerful 3rd generation procedure to generate 3D structures
% % based
% % % on several contours. The procedure generates a surface excluding
% the
% % % covered contours. A vessel structure is generated.
% % % 1st Generation: Tim Lueth reinvents analytical geometry
% % % 2nd Generation: Tim Lueth uses Delaunay triangulation
% % % 3rd Generation: Tim Lueth understands Delaunay triangulation
% (Status
% % % of: 2013-01-14)
% % %
% % % [VLN,FLcoat,varargout]=VLFLcoatPCVL([VLi])
% % % === INPUT PARAMETERS ===
% % % VLi: Planar Contour Vertex List, separated: VL1, VL2, VL3 etc.
% % % === OUTPUT RESULTS ======
% % % VLN: Vertex
% % % FLcoat: Facet list of the coat without the covers for VLBA, etc.
% % % varargout: Facet list to cover planar contour VL1, VL2, VL3 etc.
% % %
% % fnctn [VLN,FLcoat,varargout]=VLFLcoatPCVL(varargin)
% % % VLi=varargin{1}]: Facet list of the coat without the covers for
% VLBA,
% % etc.
% % varargout: Facet list to cover planar contour VL1, VL2, VL3 etc.
% %
% fnctn [VLN,FLcoat,varargout]=VLFLcoatPCVL(varargin)
% % VLi=varargin{1}]: Facet list of the coat without the covers for VLBA,
% etc.
% varargout: Facet list to cover planar contour VL1, VL2, VL3 etc.
%
exp_2013_01_14- EXPERIMENT to generate structures similar to JACO's hand
exp_2013_01_14 % exp_2013_01_14 - EXPERIMENT to generate structures similar to JACO's
% hand
% (by Tim Lueth, VLFL-Lib, 2013-JAN-14 as class: EXPERIMENTS)
%
% exp_2013_01_14
%
VLremstraightCVL(CVL)- returns a vertex list without vertices that are on straight lines
VLremstraightCVL(CVL) % VLremstraightCVL(CVL) - returns a vertex list without vertices that are on straight lines
% (by Tim Lueth, VLFL-Lib, 2013-JAN-12 as class: ANALYTICAL GEOMETRY)
%
% =======================================================================
% OBSOLETE (2017-07-13) - USE FAMILY 'CVLremstraight' INSTEAD
% =======================================================================
%
% remove points from ONE 3D vertex list contour. If points are on a
% straight line which means crossz is minimal. The contour order will
% still remain. Because of crossz, also very small distances are removed.
% Works in 2D and 3D with planar and not planar contours. (Status of:
% 2017-04-07)
%
% Introduced first in SolidGeometry 1.0
%
% See also: [ CVLremstraight ] ; CPLremstraight
%
% [NVL,i,c]=VLremstraightCVL(CVL)
% === INPUT PARAMETERS ===
% CVL: Original contour vertex list
% === OUTPUT RESULTS ======
% NVL: New contour vertex list, Original first point may be missing
% i: index list from CVL to NVL
% c: original list of ez values (area of traingle)
%
% See also: [ CVLremstraight ] ; CPLremstraight
%
VLFLboxing(VLLA,FLIF,ELB,ELT,wall)- returns for a given surface, two contours edge list, a solid box structure
VLFLboxing(VLLA,FLIF,ELB,ELT,wall) % VLFLboxing(VLLA,FLIF,ELB,ELT,wall) - returns for a given surface, two
% contours edge list, a solid box structure
% (by Tim Lueth, VLFL-Lib, 2013-JAN-10 as class: SYNTHESIZING PROCEDURES)
%
% The size of the box is related to the top contour. Used first time in
% 2013-01-09 (Status of: 2013-01-12)
%
% [VLLA,FLIF,FLOF,FLBF,FLTF]=VLFLboxing(VLLA,FLIF,ELB,ELT,[wall])
% === INPUT PARAMETERS ===
% VLLA: Vertex List
% FLIF: Facet list of the inner surface
% ELB: Bottom contour edge list
% ELT: Bottom contour edge list
% wall: wall size; default is 1
% === OUTPUT RESULTS ======
% VLLA: Vertex list
% FLIF: Facet list of the inner contour (now swapped)
% FLOF: Facet list of the outer contour (now swapped)
% FLBF: Facet list of the bottom surface
% FLTF: Facet list of the top surface
%
VLFLclosure(VL,FL,mindz,mindz,zint)- returns a surface in which the solid can be pushed in from z-direction
VLFLclosure(VL,FL,mindz,mindz,zint) % VLFLclosure(VL,FL,mindz,mindz,zint) - returns a surface in which the
% solid can be pushed in from z-direction
% (by Tim Lueth, VLFL-Lib, 2013-JAN-09 as class: SYNTHESIZING PROCEDURES)
%
% Powerful procedure for many applications. Used first time in
% exp_2013_01_09. The procedure generates a convex hull for any objects,
% so that the object can be insert into the hull using the [0 0 -1]
% direction (Status of: 2013-01-20)
%
% [VLLA,FLC,ELB,ELT]=VLFLclosure(VL,FL,[mindz,mindz,zint])
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% mindz: minimal required distance between to slices; default is 0
% mindz: maximal allowed distance between to slices; default is 1
% zint: Slicing intervall 2 x 1; default is [-inf +inf]
% === OUTPUT RESULTS ======
% VLLA: Vertex list
% FLC: Facet list of the closure surface
% ELB: Edge list of the bottom contour
% ELT: Edge list of the top contour
%
ELunsort(EL)- TEST and Development function for unsorting edge or facet lists
ELunsort(EL) % ELunsort(EL) - TEST and Development fnctn for unsorting edge or facet lists
% (by Tim Lueth, VLFL-Lib, 2013-JAN-09 as class: AUXILIARY PROCEDURES)
%
% EL=ELunsort(EL)
% === INPUT PARAMETERS ===
% EL: Original edge list
% === OUTPUT RESULTS ======
% EL: Unsorted edge list
%
% EXAMPLE: EL=ELofn(10); [EL ELunsort(EL)]
%
exp_2013_01_09- Experiment for automatic packaging, retessallation and boxing of objects
exp_2013_01_09 % exp_2013_01_09 - Experiment for automatic packaging, retessallation and
% boxing of objects
% (by Tim Lueth, VLFL-Lib, 2013-JAN-09 as class: EXPERIMENTS)
%
% This experiments focuses on the retessellation of plane surfaces
% (Status of: 2013-01-09)
%
% [VL,FL,VLN,FLN]=exp_2013_01_09
% === OUTPUT RESULTS ======
% VL: Vertex List of the STL file
% FL: Facet List of the STL file
% VLN: Package vertex list
% FLN: Package facet list
%
FLretessellation(VL,FL)- returns retesselated facets for a given solid
FLretessellation(VL,FL) % FLretessellation(VL,FL) - returns retesselated facets for a given solid
% (by Tim Lueth, VLFL-Lib, 2013-JAN-09 as class: ANALYZING PROCEDURES)
%
% The vertex list is unchanged. A retessellation is only used, if the
% number of facets is smaller.
% Used first time in exp_2013_01_09. (Status of: 2013-01-10)
%
% FL=FLretessellation(VL,FL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% === OUTPUT RESULTS ======
% FL: Retessellated facet list
%
VLFLcone(H,R,nf)- returns vertex list and facet list for a cone solid
VLFLcone(H,R,nf) % VLFLcone(H,R,nf) - returns vertex list and facet list for a cone solid
% (by Tim Lueth, VLFL-Lib, 2013-JAN-08 as class: ANALYTICAL GEOMETRY)
%
% See also: VLFLbox, VLFLring, VLFLdome, VLFLhemisphere, VLFLpost,
% VLFLcap, VLFLsnaprivet, VLFLellipse1, VLFLellipse2, VLFLellipse3,
% VLFLyarn, VLFLweave, VLFLtext, VLFLexpboard, VLFLcreateframe,
% VLFLcreateblock, VLFLcreatecross
%
% [VL,FL,FLb]=VLFLcone(H,[R,nf])
% === INPUT PARAMETERS ===
% H: Height
% R: Radius; default is H/2
% nf: Number of facets, default is 16
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list of the cone
% FLb: Facet list of the bottom
%
ELomitVLEL(VL,EL)- returns an edge list that omits edges of same direction of MULTI CONTOUR EDGE LIST
ELomitVLEL(VL,EL) % ELomitVLEL(VL,EL) - returns an edge list that omits edges of same
% direction
% (by Tim Lueth, VLFL-Lib, 2013-JAN-08 as class: AUXILIARY PROCEDURES)
%
% Some procedures generate edge lists based on grid structures.
% Nevertheless, for a polygonal description, often not all edges are
% required. This procedure cuts out edges that have the same direction.
% This procedures is more stable than ELomitedgesVLEL (Status of:
% 2013-01-08)
%
% EL=ELomitVLEL(VL,EL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% EL: Edge List, must be sorted
% === OUTPUT RESULTS ======
% EL: New Edge list, maybe shorter
%
ELdirectVLEL(VL,EL)- returns a edge list, in which all contours have the same direction than the first contour in the edge list
ELdirectVLEL(VL,EL) % ELdirectVLEL(VL,EL) - returns a edge list, in which all contours have
% the same direction than the first contour in the edge list
% (by Tim Lueth, VLFL-Lib, 2013-JAN-08 as class: ANALYTICAL GEOMETRY)
%
% Generates a contour index list. Afterwards change the direction of all
% contour edge lists as part of the contour index list in a way, that all
% contours have the same direction (right hand rule); (Status of:
% 2013-01-08)
%
% ELD=ELdirectVLEL(VL,EL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% EL: Facet list
% === OUTPUT RESULTS ======
% ELD: Directed edge list
%
parsedatestr(DStr,nf)- parse a datestr and returns the corresponding datenum and datestr
parsedatestr(DStr,nf) % parsedatestr(DStr,nf) - parse a datestr and returns the corresponding
% datenum and datestr
% (by Tim Lueth, VLFL-Lib, 2013-JAN-08 as class: AUXILIARY PROCEDURES)
%
% [dn,ds]=parsedatestr(DStr,[nf])
% === INPUT PARAMETERS ===
% DStr: Datestr in unknown format
% nf: format, default is 29
% === OUTPUT RESULTS ======
% dn: datenum
% ds: datenum
%
% EXAMPLE: [~,ds]=parsedatestr ('31.12.77')
% [~,ds]=parsedatestr ('2011-december-31')
% [~,ds]=parsedatestr ('2011-december-31',1)
%
FLofn(n)- DO NOT USE (MACRO=>SINGLE LINE) Identical to FLofVL (VL) TESSELATION
FLofn(n) % FLofn(n) - DO NOT USE (MACRO=>SINGLE LINE) Identical to FLofVL (VL)
% (by Tim Lueth, VLFL-Lib, 2013-JAN-08 as class: AUXILIARY PROCEDURES)
%
% More a macro than a procedure, so better write directly:
% FL=[ones(1,n-2); 2:n-1; 3:n]'; % tessellation of convex polygon
% (Status of: 2013-08-12)
%
% FL=FLofn(n)
% === INPUT PARAMETERS ===
% n: number of points
% === OUTPUT RESULTS ======
% FL: Facet list
%
parsedocTL(fname)- returns the documentation string related to Tim Lueth's documentation rules
parsedocTL(fname) % parsedocTL(fname) - returns the documentation string related to Tim
% Lueth's documentation rules
% (by Tim Lueth, VLFL-Lib, 2013-JAN-08 as class: FILE HANDLING)
%
% Dclass=parsedocTL(fname)
% === INPUT PARAMETERS ===
% fname: File name
% === OUTPUT RESULTS ======
% Dclass: Documentation information
%
depusewdTL(chdnum1,chdnum2)- Generates a dependency report file for TODAY and the current working directory
depusewdTL(chdnum1,chdnum2) % depusewdTL(chdnum1,chdnum2) - Generates a dependency report file for
% TODAY and the current working directory
% (by Tim Lueth, VLFL-Lib, 2013-JAN-07 as class: AUXILIARY PROCEDURES)
%
% For a directory with several hundred procedures, this can take more
% than an hour. Effort grows quadratic. At the end of day it is possible
% to detect which files have been modified, and which files could be
% effected by this changes.
% The procedure also detects which files are not documented in the "Style
% of Tim Lueth" (Status of: 2013-01-07)
%
% varargout=depusewdTL([chdnum1,chdnum2])
% === INPUT PARAMETERS ===
% chdnum1: Starting date; default is today
% chdnum2: last date;
% === OUTPUT RESULTS ======
% varargout: cell structure containing the result
%
% EXAMPLE: Was was modified between Aug 1st and 15th in 2013
% depusewdTL ('1.8.2013','15.8.2013')
%
%
exp_2013_01_07- EXPERIMENT shows the retesselation of a surface
exp_2013_01_07 % exp_2013_01_07 - EXPERIMENT shows the retesselation of a surface
% (by Tim Lueth, VLFL-Lib, 2013-JAN-07 as class: EXPERIMENTS)
%
% Uses other experiment exp_2013_01_05 (Status of: 2013-01-07)
%
% [VL,FL,UL,EL,FLC]=exp_2013_01_07
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% UL: Union list (plane surfaces)
% EL: Edge list of union 1
% FLC: Retesselated surface of union 1
%
ELboundaryFL(FL)- returns the unsorted boundary edges of a facet list
ELboundaryFL(FL) % ELboundaryFL(FL) - returns the unsorted boundary edges of a facet list
% (by Tim Lueth, VLFL-Lib, 2013-JAN-07 as class: AUXILIARY PROCEDURES)
%
% For a surface of facets that is not closed (no solid), there are edges
% that are used only in one direction. Those are the boundary edges. This
% can be used for a retessellation of a surfaces, i.e. closing the
% boundary edges by a new tessellation. ! The list is unsorted. Use
% ELconnectEL for sorting and ELomitVLEL to remove edges of the same
% direction. (Status of: 2013-01-07)
%
% [ELB,EL,oind]=ELboundaryFL(FL)
% === INPUT PARAMETERS ===
% FL: Facet list
% === OUTPUT RESULTS ======
% ELB: Edge list of the boundaries
% EL: Full edge list
% oind: index of outer an inner edges
%
% EXAMPLE: [VL,FL]=exp_2013_01_05 (2,1,4,4); app_2012_11_09 (VL,FL);
% UL=ULgenerate(VL,FL);
% EL=sortELnew(ELboundaryFL(FLofUL(UL,1)));
% hold on, VLELplots (VL,EL,'r',4)
%
VLGrahamPVL(PCVL)- returns the convex hull for a given set of vertices that are in a plane
VLGrahamPVL(PCVL) % VLGrahamPVL(PCVL) - returns the convex hull for a given set of vertices that are in a plane
% (by Tim Lueth, VLFL-Lib, 2013-JAN-06 as class: ANALYTICAL GEOMETRY)
%
% Checks first, whether all vertices are in the same plane
% replaces VLGraham of April 2012 (Status of: 2017-03-19)
%
% See also: VLGraham
%
% VL=VLGrahamPVL(PCVL)
% === INPUT PARAMETERS ===
% PCVL: planar contour vertex list
% === OUTPUT RESULTS ======
% VL: vertex list of the convex hull
%
exp_2013_01_06(fname,mag,minz,maxz,nums)- Experiment for automatic packaging
exp_2013_01_06(fname,mag,minz,maxz,nums) % exp_2013_01_06(fname,mag,minz,maxz,nums) - Experiment for automatic
% packaging
% (by Tim Lueth, VLFL-Lib, 2013-JAN-06 as class: EXPERIMENTS)
%
% A STL file ore some other object is sliced and a package is generated
% for inserting the object from the top side into the package. (Status
% of: 2013-01-08)
%
% [VL,FL,PVL,PFL]=exp_2013_01_06([fname,mag,minz,maxz,nums])
% === INPUT PARAMETERS ===
% fname: Filename, default is 'exp_2012_04_09' for the prisma
% mag: magnification (1=mm, 1000=m)
% minz: minimal z value for slicing, default is min(STL)
% maxz: maximal z value for slicing, default is min(STL)
% nums: number of slices; default is ~ slice distance=1 mm
% === OUTPUT RESULTS ======
% VL: Vertex List of the STL file
% FL: Facet List of the STL file
% PVL: Package vertex list
% PFL: Package facet list
%
% EXAMPLE: Generate a binary STL-File of a simple geometry and generate
% convex hull inside and outside
% [VL,FL,CVL,CLL,NL,PL]=exp_2012_04_09 ('',1,0,0);
% VLLLplot (CVL,CLL,'r.-',NL)
%
exp_2013_01_05 (BIC,TIC,nO,nI,wz,wx,dx,dz)- EXPERIMENT to show the use of VLFLcoverVLEL and VLFLcoatVLEL
exp_2013_01_05 (BIC,TIC,nO,nI,wz,wx,dx,dz) % exp_2013_01_05 (BIC,TIC,nO,nI,wz,wx,dx,dz) - EXPERIMENT to show the use
% of VLFLcoverVLEL and VLFLcoatVLEL
% (by Tim Lueth, VLFL-Lib, 2013-JAN-05 as class: EXPERIMENTS)
%
% This experiment is a more professional version (exp_2012_12_30,
% 2013_01_04) to test the use of different procedures:
% VLFLcoverVLEL, to tesselate contours that are in the same plane
% VLFLcoatVLEL, to connect two contours in different planes for a pipe
% (Status of: 2013-01-06)
%
% exp_2013_01_05([BIC,TIC,nO,nI,wz,wx,dx,dz])
% === INPUT PARAMETERS ===
% BIC: Number of inner contours in the bottom plane [0..2]
% TIC: Number of inner contours in the top plane [0..2]
% nO: Number of edges of outer bottom contour [3..)
% nI: Number of edges of outer top contour [3..)
% wz: Rotation degree in z axis of top plane [-360..360]
% wx: Rotation degree in x axis of top plane [-360..360]
% dx: Distance in x axis of top plane [-10..10]
% dz: Distance in z axis of top plane [-10..10]
%
% EXAMPLE: Test different cases:
% exp_2013_01_05 (1,1); % 1 pipe
% exp_2013_01_05 (0,1); % discontinued on bottom side
% exp_2013_01_05 (1,0); % discontinued on top side
% exp_2013_01_05 (2,1); % discontinued on top side
% exp_2013_01_05 (2,2,22,20,20,20,5)
%
TofPCVL(CVL)- returns the HT matrix for a planar contour vertex list
TofPCVL(CVL) % TofPCVL(CVL) - returns the HT matrix for a planar contour vertex list
% (by Tim Lueth, VLFL-Lib, 2013-JAN-05 as class: AUXILIARY PROCEDURES)
%
% See also: VLFLcoatPCVL, CVLplot, TofVL
%
% T=TofPCVL(CVL)
% === INPUT PARAMETERS ===
% CVL: Planar contour vertex list
% === OUTPUT RESULTS ======
% T: Transformation matrix
%
FLcoatVLEL(VL,ELA,ELB)- returns the facets to coat contours in different plane to generate a coating surface
FLcoatVLEL(VL,ELA,ELB) % FLcoatVLEL(VL,ELA,ELB) - returns the facets to coat contours in
% different plane to generate a coating surface
% (by Tim Lueth, VLFL-Lib, 2013-JAN-05 as class: SYNTHESIZING PROCEDURES)
%
% Generic procedure that manages different parameter situations in an
% object oriented manner. Two sets of contours are handled. The two
% contour sets have to have the same number of contour. They have to be
% ordered the same way (outer, inner 1 , inner 2, ... inner n). Contours
% of one set have to be in the same plane. All inner contours have to be
% FULLY inside of the outer contour. No crossings are allowed. (Status
% of: 2013-01-05)
%
% [FL,FLA,FLB]=FLcoatVLEL(VL,ELA,ELB)
% === INPUT PARAMETERS ===
% VL: Vertex list
% ELA: Edge list the bottom contours (z-Vector)
% ELB: Edge list the top contours
% === OUTPUT RESULTS ======
% FL: Facet list of a cover surface related to the direction of ELO
% FLA: Covers the discontinued vessels of A
% FLB: Covers the discontinued vessels of B
%
exp_2013_01_04 ()- EXPERIMENT for testing FLcoverVLEL and FLcoatVLEL
exp_2013_01_04 () % exp_2013_01_04 () - EXPERIMENT for testing FLcoverVLEL
% (by Tim Lueth, VLFL-Lib, 2013-JAN-04 as class: EXPERIMENTS)
%
% similar to exp_2012_12_30 (Status of: 2013-01-04)
%
% exp_2013_01_04([])
%
VLELcat(VL1,EL1,)- returns the connection of several VLs and ELs
VLELcat(VL1,EL1,) % VLELcat(VL1,EL1,) - returns the connection of several VLs and ELs
% (by Tim Lueth, VLFL-Lib, 2013-JAN-04 as class: AUXILIARY PROCEDURES)
%
% The n vertex lists are just concatenated, also the n edge lists are
% just concatenated. The variable output parameter are the changed edge
% lists from 2 to n. (Status of: 2013-01-05)
%
% [VL1,ELn,EL1,varargout]=VLELcat(VL1,EL1,[])
% === INPUT PARAMETERS ===
% VL1: Vertex list 1
% EL1: Vertex list 2
% varargin = {VL2,EL2,VL3,EL3,...,VLn,ELn}
% === OUTPUT RESULTS ======
% VL1: Concatenated vertex list
% ELn: Concatenated edge list
% EL1: corrected edge list EL1
% varargout: corrected edge list EL2 ... ELn
%
FLcoverVLEL(VL,ELO,ELI)- returns the facets to close contours in a plane to generate a cover surface
FLcoverVLEL(VL,ELO,ELI) % FLcoverVLEL(VL,ELO,ELI) - returns the facets to close contours in a
% plane to generate a cover surface
% (by Tim Lueth, VLFL-Lib, 2013-JAN-04 as class: SYNTHESIZING PROCEDURES)
%
% Generic procedure that manages different parameter situations in an
% object oriented manner.
% ALL VERTICES OF ALL CONTOURS HAVE TO BE IN THE SAME PLANE and describe
% plane contour vertex lists in the same plane. All inner contours have
% to be FULLY inside of the outer contour. No crossings are allowed.
% (Status of: 2013-01-05)
%
% FL=FLcoverVLEL(VL,ELO,[ELI])
% === INPUT PARAMETERS ===
% VL: Vertex list
% ELO: Edge list of an outer contour; the first contour is the outer one
% ELI: Optional inner contours, could also be part of ELO
% === OUTPUT RESULTS ======
% FL: Facet list of a cover surface related to the direction of ELO
%
strfindex(S,fnd,exch)- returns a string with found and replaced character chains
strfindex(S,fnd,exch) % strfindex(S,fnd,exch) - returns a string with found and replaced character chains
% (by Tim Lueth, VLFL-Lib, 2013-JAN-04 as class: TEXT PROCEDURES)
%
% Obsolete since strrep exist
% see also strrep (Status of: 2017-01-02)
%
% See also: strrep, strrepn
%
% S=strfindex(S,fnd,exch)
% === INPUT PARAMETERS ===
% S: Original String
% fnd: String to find
% exch: String to exchange
% === OUTPUT RESULTS ======
% S: New String
%
str2cell(S,trime)- returns a cell consisting of the lines of a string
str2cell(S,trime) % str2cell(S,trime) - returns a cell consisting of the lines of a string
% (by Tim Lueth, VLFL-Lib, 2013-JAN-04 as class: TEXT PROCEDURES)
%
% this fnctn is different from cellstr (Status of: 2017-06-25)
%
% See also: cell2str, cell2array, cellstrfind, plotannotation
%
% C=str2cell(S,[trime])
% === INPUT PARAMETERS ===
% S: String
% trime: if 'trim'=> skip empty lines
% === OUTPUT RESULTS ======
% C: Cell
%
cell2str(C)- returns a string which lines are the cell list
cell2str(C) % cell2str(C) - returns a string which lines are the cell list
% (by Tim Lueth, VLFL-Lib, 2013-JAN-04 as class: TEXT PROCEDURES)
%
% See also: str2cell, cell2array, cellstrfind
%
% S=cell2str(C)
% === INPUT PARAMETERS ===
% C: Cell with lines of strings
% === OUTPUT RESULTS ======
% S: String
%
depuseTL(fname,dname,PrmStr)- returns all files of a directory that use a named procedure
depuseTL(fname,dname,PrmStr) % depuseTL(fname,dname,PrmStr) - returns all files of a directory that use a named procedure
% (by Tim Lueth, VLFL-Lib, 2013-JAN-03 as class: AUXILIARY PROCEDURES)
%
% depuseTL shows all fnctns that uses a named procedure
% depfunTL shows all fnctns that are used in a procedure
% If a prompt string is used, a dependency report is generated. This
% procedure can take several minutes up to hours, if there are several
% hundred fnctns in a directory. The dependencies are written in text
% files (Status of: 2017-01-04)
%
% See also: depuseString, depuseToolbox, publishTL, pcodeTL, depfunTL,
% pcodedirTL
%
% [ufiles,mfiles,DepStr,EStr]=depuseTL(fname,[dname,PrmStr])
% === INPUT PARAMETERS ===
% fname: Name of fnctn
% dname: Name of directory
% PrmStr: prompt for dependency report; default is ''
% === OUTPUT RESULTS ======
% ufiles: list of all m files that use fnctn fname
% mfiles: list of all m files in the directory
% DepStr: Dependence report only of PrmStr ~= ''
% EStr: Sorted string cells containing result without double
%
% EXAMPLE: Use of of FTelement.m
% [u,m,s]=depuseTL ('FTelement',[],'==>')
% [~,~,~,E]=depuseTL ('VLFLclose2D',[],'=')
%
THLofVL(VL)- returns the tetrahedron list of a vertex list
THLofVL(VL) % THLofVL(VL) - returns the tetrahedron list of a vertex list
% (by Tim Lueth, VLFL-Lib, 2013-JAN-01 as class: AUXILIARY PROCEDURES)
%
% Simple procedure that uses Matlab's Delaunay triangulation (Status of:
% 2013-01-01)
%
% THL=THLofVL(VL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% === OUTPUT RESULTS ======
% THL: Tetrahedron list
%
exp_2012_12_30 ()- EXPERIMENT for testing FLofVL and FLofVLEL and VLFLclose
exp_2012_12_30 () % exp_2012_12_30 () - EXPERIMENT for testing FLofVL and FLofVLEL and
% VLFLclose
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-30 as class: EXPERIMENTS)
%
% similar to exp_2013_01_04 (Status of: 2013-01-04)
%
% exp_2012_12_30([])
%
exp_2012_12_29- generates a revolute link
exp_2012_12_29 % exp_2012_12_29 - generates a revolute link
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-29 as class: EXPERIMENTS)
%
% exp_2012_12_29
%
SGbearing(l,Ro,no,Ri,Rd,ni,wall,nf)- returns a bearing for a joint
SGbearing(l,Ro,no,Ri,Rd,ni,wall,nf) % SGbearing(l,Ro,no,Ri,Rd,ni,wall,nf) - returns a bearing for a joint
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-29 as class: SYNTHESIZING PROCEDURES)
%
% General joint or bearing generator. Extracted from exp_2012_12_27.
% (Status of: 2012-12-29)
%
% [FTA,FTB]=SGbearing([l,Ro,no,Ri,Rd,ni,wall,nf])
% === INPUT PARAMETERS ===
% l: length of the joint
% Ro: Radius of the outer ring
% no: number of facets of the outer ring
% Ri: Radius of the inner ring
% Rd: Radius of the drill boring
% ni: number of facets of the boring
% wall: change of radius
% nf: number of facet of the bearing
% === OUTPUT RESULTS ======
% FTA: Solid of the inner part
% FTB: Solid of the outer part
%
% EXAMPLE: Just try
% [A,B]=SGbearing (10,40,[],30,10,8,1);
% app_2012_11_09 (A,'m'); SGplot (B,'g')
%
exp_2012_12_27(l,Ro,no,Ri,Rd,ni,wall,nf)- returns a bearing for a joint
exp_2012_12_27(l,Ro,no,Ri,Rd,ni,wall,nf) % exp_2012_12_27(l,Ro,no,Ri,Rd,ni,wall,nf) - returns a bearing for a joint
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-27 as class: SYNTHESIZING PROCEDURES)
%
% General joint or bearing generator (Status of: 2012-12-28)
%
% [FTA,FTB]=exp_2012_12_27([l,Ro,no,Ri,Rd,ni,wall,nf])
% === INPUT PARAMETERS ===
% l: length of the joint
% Ro: Radius of the outer ring
% no: number of facets of the outer ring
% Ri: Radius of the inner ring
% Rd: Radius of the drill boring
% ni: number of facets of the boring
% wall: change of radius
% nf: number of facet of the bearing
% === OUTPUT RESULTS ======
% FTA: Solid of the inner part
% FTB: Solid of the outer part
%
% EXAMPLE: Just try
% exp_2012_12_27
%
%
ELofn(n)- returns an edge list for a contour of n points
ELofn(n) % ELofn(n) - returns an edge list for a contour of n points
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-27 as class: AUXILIARY PROCEDURES)
%
% EL=ELofn(n)
% === INPUT PARAMETERS ===
% n: number of points
% === OUTPUT RESULTS ======
% EL: Edge list
%
VLFLcap(ZP,ZD,RX,RY,wall,nfo,nfi)- returns a tube covered with a cap
VLFLcap(ZP,ZD,RX,RY,wall,nfo,nfi) % VLFLcap(ZP,ZD,RX,RY,wall,nfo,nfi) - returns a tube covered with a cap
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-27 as class: SYNTHESIZING PROCEDURES)
%
% similar to experiment 2012_12_24 (Status of: 2012-12-29)
%
% [VL,FL,FLf]=VLFLcap(ZP,ZD,RX,RY,wall,[nfo,nfi])
% === INPUT PARAMETERS ===
% ZP: Size in Z of the post
% ZD: Size in Z of the dome
% RX: Radius in X
% RY: Radius in Z
% wall: thickness of the wall
% nfo: number of facets of the outer contour
% nfi: number of facets of the inner contour
% === OUTPUT RESULTS ======
% VL: Vertex list of the object
% FL: Facet list of the post plus dome without floor
% FLf: Facet list of the floor
%
VLFLthreadnut(H,D,d,di,h,alpha)- generates a screw nut's thread
VLFLthreadnut(H,D,d,di,h,alpha) % VLFLthreadnut(H,D,d,di,h,alpha) - generates a screw nut's thread
% (by Marie L. Lueth, VLFL-Lib, 2012-DEZ-27 as class: SYNTHESIZING
% PROCEDURES)
%
% [VL,FL]=VLFLthreadnut(H,D,d,di,h,[alpha])
% === INPUT PARAMETERS ===
% H: Height of the thread
% D: Outer diameter
% d: Core diameter
% di: Inner diameter
% h: Thread pitch
% alpha: Thread angle; default is pi/3 (60 Degree)
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: Generating the thread of a DIN 13 M8 nut with 5mm height.
% [VL,FL]=VLFLthreadnut (5,8,6.65,7.33,1.25);
% VLFLplot (VL,FL); axis equal;
%
VLFLthread(H,D,d,di,h,alpha)- generates a screw's thread
VLFLthread(H,D,d,di,h,alpha) % VLFLthread(H,D,d,di,h,alpha) - generates a screw's thread
% (by Marie L. Lueth, VLFL-Lib, 2012-DEZ-27 as class: SYNTHESIZING
% PROCEDURES)
%
% [VL,FL]=VLFLthread(H,D,d,di,h,[alpha])
% === INPUT PARAMETERS ===
% H: Height of the thread
% D: Outer diameter
% d: Core diameter
% di: Inner diameter
% h: Thread pitch
% alpha: Thread angle; default is pi/3 (60 Degree)
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: Generating the thread of a DIN 13/14 M5 screw with 10mm height
% and 4.4mm inner diameter.
% [VL,FL]=VLFLthread (10,5,3.89,4.4,0.8);
% VLFLplot (VL,FL); axis equal;
%
TriRepofVLFL(VL,FL,dw)- returns a DelaunayTri representation of a solid
TriRepofVLFL(VL,FL,dw) % TriRepofVLFL(VL,FL,dw) - returns a DelaunayTri representation of a solid
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-27 as class: AUXILIARY PROCEDURES)
%
% Feature edges still have a problem, for helix type objects, because of
% the delaunay concept (Status of: 2013-08-02)
%
% [dt,fe]=TriRepofVLFL(VL,FL,[dw])
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% dw: Feature angle; default pi/6
% === OUTPUT RESULTS ======
% dt: DelaunayTri class object
% fe: Features edges, Optional
%
% EXAMPLE: VLFLplot (VL,FL,'m')
% [~,EL]=TriRepofVLFL (VL,FL);
% VLELplots (VL,EL,'k',1); show
%
VLELplots (VL,EL,c,w,t,b,f)- plots lines given as vertex list and edge list
VLELplots (VL,EL,c,w,t,b,f) % VLELplots (VL,EL,c,w,t,b,f) - plots lines given as vertex list and edge list
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-27 as class: VISUALIZATION)
%
% This procedure is different to VLELplot (Status of: 2017-02-08)
%
% See also: VLELplots, CPLplot, PLplot, VLplot
%
% VLELplots(VL,EL,[c,w,t,b,f])
% === INPUT PARAMETERS ===
% VL: Vertex list
% EL: Edge list
% c: Optional color of desired edges; default os 'r*-'
% w: Optional line width; default is 1
% t: Size of a cone shaped arrow tip, default is 0
% b: Size of a cube showing the start point of a contour; default is 0
% f: Size of a ring showing the end point of a contour; default is 0
%
exp_2012_12_24- EXPERIMENT to generate a post with a dome
exp_2012_12_24 % exp_2012_12_24 - EXPERIMENT to generate a post with a dome
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-25 as class: EXPERIMENTS)
%
% Since the JACO Elements are in fact not a vessel type but a post with a
% dome, this procedure simply generates these elements (Status of:
% 2012-12-25)
%
% exp_2012_12_24
%
VLFLpost(h,RX,RY,wall,nfo,nfi)- returns VL and FL of a hollow post
VLFLpost(h,RX,RY,wall,nfo,nfi) % VLFLpost(h,RX,RY,wall,nfo,nfi) - returns VL and FL of a hollow post
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-25 as class: SYNTHESIZING PROCEDURES)
%
% VLFLpost corresponds to VLFLdome and VLFLhemisphere. It is very similar
% to VLFLellipse, but uses PLcircle to generate the contours (Status of:
% 2012-12-29)
%
% [VL,FL,FLf,FLc]=VLFLpost(h,RX,RY,wall,[nfo,nfi])
% === INPUT PARAMETERS ===
% h: Height in Z
% RX: Radius in X
% RY: Radius in Y
% wall: wall thickness
% nfo: number of facets of the outer ring; default is nofrd(max(RX,RY))
% nfi: number of facets of the inner ring; default is nfo
% === OUTPUT RESULTS ======
% VL: Vertex list of the post
% FL: Facet list of the post
% FLf: Facet list of the floor
% FLc: Facet list of the ceiling
%
VLFLhemisphere(CL,RZ,wmin,wmax)- returns a surface of a hemishpere
VLFLhemisphere(CL,RZ,wmin,wmax) % VLFLhemisphere(CL,RZ,wmin,wmax) - returns a surface of a hemishpere
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-24 as class: SYNTHESIZING PROCEDURES)
%
% =======================================================================
% OBSOLETE (2017-03-25) - USE FAMILY 'SGsphere' INSTEAD
% =======================================================================
%
% [VL,FL,FLfloor]=VLFLhemisphere(CL,RZ,[wmin,wmax])
% === INPUT PARAMETERS ===
% CL: Contour list
% RZ: Radius in Z
% wmin: minimum angle (default is 0)
% wmax: maximum angle (default is 90)
% === OUTPUT RESULTS ======
% VL: Vertex list of the hemishpere
% FL: Facet list of the hemishpere
% FLfloor: Facet list of the floor
%
VLFLdome(RZ,RX,RY,wall,nfo,nfi)- return VL and FL of a dome
VLFLdome(RZ,RX,RY,wall,nfo,nfi) % VLFLdome(RZ,RX,RY,wall,nfo,nfi) - return VL and FL of a dome
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-24 as class: SYNTHESIZING PROCEDURES)
%
% [VL,FL,FLf]=VLFLdome(RZ,RX,RY,wall,[nfo,nfi])
% === INPUT PARAMETERS ===
% RZ: Radius in Z (Height)
% RX: Radius in X
% RY: Radius in Y
% wall: Thickness of the dome
% nfo: Number of facets of the outer sphere
% nfi: Number of facets of the inner sphere; default is nfo
% === OUTPUT RESULTS ======
% VL: Vertex list of inner and outer wall
% FL: Facet list of inner and outer wall
% FLf: Facet list of the dome's floor
%
VLtransR(VL,R)- transforms all points of a vertex list using a rotation matrix
VLtransR(VL,R) % VLtransR(VL,R) - transforms all points of a vertex list using a rotation matrix
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-16 as class: AUXILIARY PROCEDURES)
%
% See also: VLtransT, VLtransP, VLtrans1, VLtrans0, VLtransT, VLtrans,
% VLtransN
%
% VL=VLtransR(VL,[R])
% === INPUT PARAMETERS ===
% VL: Original vertex list
% R: 3x3 Rotation matrix
% === OUTPUT RESULTS ======
% VL: Transformed vertex list
%
% EXAMPLE: VL=VLtransR(VL,rot(pi/2,0,0))
%
dofn(n)- returns the radius relation between a radius and a n-polygon
dofn(n) % dofn(n) - returns the radius relation between a radius and a n-polygon
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-15 as class: ANALYTICAL GEOMETRY)
%
% Similar concept as nofrd. If a polygon is created instead of a real
% circle, either the edges or the points have not the correct distance to
% the origin. (Status of: 2017-01-02)
%
% See also: nofrd, sofrd, phiofsr
%
% [d,id]=dofn(n)
% === INPUT PARAMETERS ===
% n: number of edges
% === OUTPUT RESULTS ======
% d: magnification of the point distance
% id: 1/d reduction of the edge distance
%
exp_2012_12_15 (nf,d,ezd,cn,kr,Ptype)- EXPERIMENT same as exp_2012_11_25 and exp2012-12-12 but uses VLRadius4P instead of VLBezier4P
exp_2012_12_15 (nf,d,ezd,cn,kr,Ptype) % exp_2012_12_15 (nf,d,ezd,cn,kr,Ptype) - EXPERIMENT same as
% exp_2012_11_25 and exp2012-12-12 but uses VLRadius4P instead of
% VLBezier4P
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-15 as class: EXPERIMENTS)
%
% Generates a link between two tubes, and uses the improved procedures
% such as: ULgenerate, crosspointVLFL, PLELtube, VLBezier4P, VLRadius4P,
% VLFLcontourtube, VLFLpprojectPLEL, VLFLtextattachVLUL. It also uses the
% advanced version of T2P.
% It is able to generate vessel type robot structural link (Status of:
% 2012-12-29)
%
% exp_2012_12_15([nf,d,ezd,cn,kr,Ptype])
% === INPUT PARAMETERS ===
% nf: number of facets of the tube; default is nofrd
% d: diameter of the tube; default is 40
% ezd: direction of the flange give by 'i','ii' etc.
% cn: number of step between start and end (-2); default 40
% kr: bending radius; default is 1*d/2
% Ptype: 'B'ezier oder 'R'adius; default is 'R'
%
% EXAMPLE: show different colon meshes (not weaved)
% exp_2012_12_15 (20,[],'I',20,[],'R')
% exp_2012_12_15 (20,[],'II',40,[],'B')
% exp_2012_12_15 (20,[],'III',60,[],'B')
%
VLFLconnect2VLEL(VL1,EL1,VL2,EL2)- returns the facets of the outside wall of a tube between to Contours
VLFLconnect2VLEL(VL1,EL1,VL2,EL2) % VLFLconnect2VLEL(VL1,EL1,VL2,EL2) - returns the facets of the outside
% wall of a tube between to Contours
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-14 as class: SYNTHESIZING PROCEDURES)
%
% If two contours are gives as vertex list and edge list, this procedure
% returns a facet list that generates a tube between these two contours.
% It is used to connect two bodies if VLFLpprojectPLEL was unable to
% generate an attachment body.
% Use VLFLpprojectPLEL to attach a vessel orthogonal to a vessel structure
% Use VLFLconnect2VLEL to connect to vessel in line to a vessel structure
% (Status of: 2012-12-15)
%
% [VL,FL,FLCap1,FLCap2]=VLFLconnect2VLEL(VL1,EL1,VL2,EL2)
% === INPUT PARAMETERS ===
% VL1: Vertex list of contour 1
% EL1: Edge list of contour 1
% VL2: Vertex list of contour 2
% EL2: Edge list of contour 2
% === OUTPUT RESULTS ======
% VL: Vertex list of the connector
% FL: Facet list of the connector
% FLCap1: Cap on side 1
% FLCap2: Cap on side 2
%
exp_2012_12_12 (nf,d,ezd,cn)- EXPERIMENT same as exp_2012_11_25 but uses VLRadius4P instead of VLBezier4P
exp_2012_12_12 (nf,d,ezd,cn) % exp_2012_12_12 (nf,d,ezd,cn) - EXPERIMENT same as exp_2012_11_25 but
% uses VLRadius4P instead of VLBezier4P
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-12 as class: EXPERIMENTS)
%
% Generates a link between two tube, and uses the improved procedures
% such as: ULgenerate, crosspointVLFL, PLELtube, VLBezier4P, VLRadius4P,
% VLFLcontourtube, VLFLpprojectPLEL, VLFLtextattachVLUL. It also uses the
% advanced version of T2P. (Status of: 2012-12-12)
%
% exp_2012_12_12([nf,d,ezd,cn])
% === INPUT PARAMETERS ===
% nf: number of facets of the tube; default is nofrd
% d: diameter of the tube; default is 40
% ezd: direction of the flange give by 'i','ii' etc.
% cn: number of step between start and end (-2); default 40
%
% EXAMPLE: show different colon meshes (not weaved)
% exp_2012_12_12 (20,[],'I',20)
% exp_2012_12_12 (20,[],'II',40)
% exp_2012_12_12 (20,[],'III',60)
%
ELomitedgesVLEL(VL,EL)- returns an edge list that omits edges of same direction
ELomitedgesVLEL(VL,EL) % ELomitedgesVLEL(VL,EL) - returns an edge list that omits edges of same
% direction
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-11 as class: AUXILIARY PROCEDURES)
%
% Some procedures generate edge lists based on grid structures.
% Nevertheless, for a polygonal description, often not all edges are
% required. This procedure cuts out edges that have the same direction.
% (Status of: 2013-01-12)
%
% EL=ELomitedgesVLEL(VL,EL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% EL: Edge List, must be sorted
% === OUTPUT RESULTS ======
% EL: New Edge list, maybe shorter
%
VLFLtextimage(text,dt,t,sx,sy,sz)- returns vertex/facet list for a text string
VLFLtextimage(text,dt,t,sx,sy,sz) % VLFLtextimage(text,dt,t,sx,sy,sz) - returns vertex/facet list for a text string
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-11 as class: TEXT PROCEDURES)
%
% This is q quite generic fnctn, accelerated by the wish of Jelena Prsa
% (Status of: 2017-03-20)
%
% See also: CPLtextimage, imageoftext, VLofimage, CPLoftext, SGofCPLz
%
% [VL,FL,dx,dy,dz]=VLFLtextimage(text,[dt,t,sx,sy,sz])
% === INPUT PARAMETERS ===
% text: String consisting of characters 'TL:-MXVI'
% dt: Pixel size
% t: Thickness of the base plate [0..-t]; default is 1
% sx: Size in x; default is 0, i.e. no scaling
% sy: Size in y; default is 0, i.e. no scaling
% sz: Size in z; default is 0, i.e. no scaling
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet List
% dx: Size in x [0..x]
% dy: Size in y [0..y]
% dz: Size in x [0..z]
%
% EXAMPLE: Generate todays date as plate:
% [VL,FL,d]=VLFLtextimage('TL-MMXI-XII-XVII');
% VLFLwriteSTL (VL,FL,'exp_2011_12_17', 'by Tim C Lueth';
%
datestrroman(S)- returns a datestring as roman number
datestrroman(S) % datestrroman(S) - returns a datestring as roman number
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-11 as class: AUXILIARY PROCEDURES)
%
% See also: roman
%
% S=datestrroman([S])
% === INPUT PARAMETERS ===
% S: datestr YYYY-MM-DD; default is datestr
% === OUTPUT RESULTS ======
% S: roman number string
%
roman(n)- returns a number as roman number
roman(n) % roman(n) - returns a number as roman number
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-11 as class: AUXILIARY PROCEDURES)
%
% See also: roman, datestrroman
%
% [S,nL]=roman(n)
% === INPUT PARAMETERS ===
% n: number
% === OUTPUT RESULTS ======
% S: String of roman number
% nL: separated divisor list
%
% EXAMPLE: roman (2012)
%
exp_2012_12_11(wmax,R,nmax,rz)- EXPERIMENT similar to exp_2012_12_09, but extends the line into a tube structure.
exp_2012_12_11(wmax,R,nmax,rz) % exp_2012_12_11(wmax,R,nmax,rz) - EXPERIMENT similar to exp_2012_12_09,
% but extends the line into a tube structure.
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-11 as class: EXPERIMENTS)
%
% This experiment is used to test the new procedureality of T2P in
% combination with (Status of: 2012-12-12)
%
% AL=exp_2012_12_11([wmax,R,nmax,rz])
% === INPUT PARAMETERS ===
% wmax: Maximal radius for direction change; default 45 degree
% R: Minimal Radius; default is 5
% nmax: Maximal number before a break; default is 100
% rz: rotation angle (degree); default is 0
% === OUTPUT RESULTS ======
% AL: Vertex list
%
% EXAMPLE: Just try
% AL=exp_2012_12_11;
%
VLRadiusC(VL,wmax,R,nmax)- returns a contour based on a vertex list using VLRadius4P
VLRadiusC(VL,wmax,R,nmax) % VLRadiusC(VL,wmax,R,nmax) - returns a contour based on a vertex list
% using VLRadius4P
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-10 as class: ANALYTICAL GEOMETRY)
%
% Uses a vertex list with an even number of point. Then using VLRadius4P
% to smoothen the edges by adding a radius contour at the 2nd, 3rd, 4th,
% n-1th segment. The 1st, 3rd, 5th, etc. segments are unchanged (Status
% of: 2012-12-10)
%
% [AL,NVL]=VLRadiusC(VL,wmax,R,[nmax])
% === INPUT PARAMETERS ===
% VL: Vertex list
% wmax: Maximal direction change angle
% R: Minimal Radius of the curve
% nmax: Maximum length of a radius field; default is 40
% === OUTPUT RESULTS ======
% AL: Vertex list of the specified contour
% NVL: Vertex list with more supporting lines
%
VLRadius3P(p0,p1,p2,wmax,R,nmax)- returns a contour based on 3 points similar to VLRadius4P
VLRadius3P(p0,p1,p2,wmax,R,nmax) % VLRadius3P(p0,p1,p2,wmax,R,nmax) - returns a contour based on 3 points
% similar to VLRadius4P
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-10 as class: ANALYTICAL GEOMETRY)
%
% Generates from 2 segments, defined by 3 points a curved 2nd segment,
% that uses a radial curve to transfer the first segment as tangent into
% the 2nd segment the third point is finally hit, but not the tangent of
% the 3rd point. The procedure is the core of VLRadius4P, but may not
% often of use independently. The procedure delivers just the missing
% points! (Status of: 2012-12-10)
%
% VL=VLRadius3P(p0,p1,p2,wmax,R,nmax)
% === INPUT PARAMETERS ===
% p0: 1st point
% p1: 2nd point
% p2: 3rd point
% wmax: Maximal direction change angle
% R: Minimal Radius of the curve
% nmax: maximum length of a radius field; default is 40
% === OUTPUT RESULTS ======
% VL: Vertex list of the specified contour without the given three points
%
VLRadius4P(p0,p1,p2,p3,wmax,R,nmax)- returns a contour based on 4 points similar to VLBezier4P
VLRadius4P(p0,p1,p2,p3,wmax,R,nmax) % VLRadius4P(p0,p1,p2,p3,wmax,R,nmax) - returns a contour based on 4
% points similar to VLBezier4P
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-10 as class: ANALYTICAL GEOMETRY)
%
% Generates from 3 segments, defined by 4 points a curved 2nd segment,
% that uses a radial curve to transfer the first segment as tangent into
% the 2nd segment and the tangent of the 2nd segment is the 3rd segment.
% The procedure can be used to defined curves between an even number of
% points. (4:6:8:…). The second delivered vertex list has more supporting
% point on long straight lines. (Status of: 2012-12-10)
%
% [VL,NVL]=VLRadius4P(p0,p1,p2,p3,wmax,R,[nmax])
% === INPUT PARAMETERS ===
% p0: 1st point
% p1: 2nd point
% p2: 3rd point
% p3: 4th point
% wmax: Maximal direction change angle
% R: Minimal Radius of the curve
% nmax: maximum length of a radius field; default is 40
% === OUTPUT RESULTS ======
% VL: Vertex list of the specified contour
% NVL: Vertex list with more supporting lines
%
VLLuethC(VL,wmax,lmin,nmax)- returns a vertex list of a contour with defined angles and segments
VLLuethC(VL,wmax,lmin,nmax) % VLLuethC(VL,wmax,lmin,nmax) - returns a vertex list of a contour with
% defined angles and segments
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-09 as class: OBSOLETE PROCEDURES)
%
% OBSOLETE replaced by VLRadius4P and VLRadiusC
% This is an important procedure as alternative to VLBezierC. The
% procedures tries to insert additional points into a 3D vertex contour
% list to guarantee a minimal direction change over a minimal distance.
% In the worst case a sphere is generated. (Status of: 2012-12-09)
%
% [VL,n]=VLLuethC(VL,[wmax,lmin,nmax])
% === INPUT PARAMETERS ===
% VL: Original vertex list
% wmax: maximum change between two segments; default is 45 degree
% lmin: minimal segment length; default is 5 mm
% nmax: maximum number of points allowed; default is 20
% === OUTPUT RESULTS ======
% VL: Modified vertex list
% n: Length of vertex list
%
% EXAMPLE: Smoothen of a simple Z-shape
% VL=[0 -4 0;0 0 1;10 -8 0;10 +4 1];
% VLplot (VL,'c*-'); hold on
% AL=VLLuethC (VL);
% VLplot (AL,'b*-')
%
exp_2012_12_09(wmax,R,nmax,rz)- Experiment that shows the insertion of points to generate links with defined angles and segment length
exp_2012_12_09(wmax,R,nmax,rz) % exp_2012_12_09(wmax,R,nmax,rz) - Experiment that shows the insertion of
% points to generate links with defined angles and segment length
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-09 as class: EXPERIMENTS)
%
% This procedures shows how to insert points into a point list to make
% sure that neither a change of direction is bigger than specified and
% also none of the additional segment length are shorter than a specified
% length. (Status of: 2012-12-10)
%
% [AL,nA]=exp_2012_12_09([wmax,R,nmax,rz])
% === INPUT PARAMETERS ===
% wmax: Maximal radius for direction change; default 45 degree
% R: Minimal Radius; default is 5
% nmax: Maximal number before a break; default is 100
% rz: rotation angle (degree); default is 0
% === OUTPUT RESULTS ======
% AL: Vertex list
% nA: length of vertex list
%
% EXAMPLE: Maximal 30 degree, length 1, 200 points and 30 degree turn of
% the example
% [AL,n]=exp_2012_12_09 (30,1,200,30); n
%
sortFL(XFL)- returns a sorted and circular shifted facet list (see FLsort)
sortFL(XFL) % sortFL(XFL) - returns a sorted and circular shifted facet list (see
% FLsort)
% (by Tim Lueth, VLFL-Lib, 2012-DEZ-02 as class: AUXILIARY PROCEDURES)
%
% This procedure ensures that the first index of a facet list column is
% always smaller than the 2nd and 3rd. The rows are circular shifted and
% rotated to achieve that. Fast implementation. Developed a second time
% but this time much faster than FLsort (Status of: 2013-01-06)
%
% XFL=sortFL(XFL)
% === INPUT PARAMETERS ===
% XFL: Facet list
% === OUTPUT RESULTS ======
% XFL: Sorted facet list
%
deployTL- Procedure that explains how to install the application deployment tools
deployTL % deployTL - Procedure that explains how to install the application
% deployment tools
% (by Tim Lueth, VLFL-Lib, 2012-NOV-27 as class: USER INTERFACE)
%
% deployTL
%
VLFLplothide;- selects a patch (VLFL) by ginput and sets it as invisible
VLFLplothide; % VLFLplothide; - selects a patch (VLFL) by ginput and sets it as
% invisible
% (by Tim Lueth, VLFL-Lib, 2012-NOV-25 as class: USER INTERFACE)
%
% VLFLplothide;
%
exp_2012_11_25 (nf,d,ezd,cn)- EXPERIMENT like exp_2012_11_12 but much easier to read
exp_2012_11_25 (nf,d,ezd,cn) % exp_2012_11_25 (nf,d,ezd,cn) - EXPERIMENT like exp_2012_11_12 but much
% easier to read
% (by Tim Lueth, VLFL-Lib, 2012-NOV-25 as class: EXPERIMENTS)
%
% Generates a link between two tube, and uses the improved procedures
% such as: ULgenerate, crosspointVLFL, PLELtube,
% VLBezier4P,VLFLcontourtube, VLFLpprojectPLEL, VLFLtextattachVLUL.
% (Status of: 2012-11-25)
%
% exp_2012_11_25([nf,d,ezd,cn])
% === INPUT PARAMETERS ===
% nf: number of facets of the tube; default is nofrd
% d: diameter of the tubel; default is 40
% ezd: direction of the flange give by 'i','ii' usw.
% cn: number of step between start and end (-2); default 40
%
% EXAMPLE: show different colon meshes (not weaved)
% exp_2012_11_25 (20,[],'I',20)
% exp_2012_11_25 (40,[],'II',40)
% exp_2012_11_25 (60,[],'V',60)
% exp_2012_11_25 (80,[],'VI',80)
%
ELuniqueofFL(FL)- returns a unique list of all edges from a facet list
ELuniqueofFL(FL) % ELuniqueofFL(FL) - returns a unique list of all edges from a facet list
% (by Marie Lueth & Tim Lueth, VLFL-Lib, 2012-NOV-25 as class: AUXILIARY
% PROCEDURES)
%
% All edges in a solid are used twice in the facet list in opposite
% direction. Sometimes there is a need to have a list of these edges in
% only one direction (Status of: 2015-01-31)
%
% Introduced first in SolidGeometry 1.0
%
% See also: ELunique
%
% EL=ELuniqueofFL(FL)
% === INPUT PARAMETERS ===
% FL: Facet list
% === OUTPUT RESULTS ======
% EL: Edge list sorted by first vertex index
%
% EXAMPLE: Draw the edges of a cuboid
% [VL,FL]=VLFLbox(10,10,10);
% EL=ELuniqueofFL(FL);
% VLELplot (VL,EL);
%
% See also: ELunique
%
rad(w)- very simple procedure to convert deg into rad
rad(w) % rad(w) - very simple procedure to convert deg into rad
% (by Tim Lueth, VLFL-Lib, 2012-NOV-24 as class: AUXILIARY PROCEDURES)
%
% see also deg (Status of: 2013-08-15)
%
% w=rad(w)
% === INPUT PARAMETERS ===
% w: Angle in Deg
% === OUTPUT RESULTS ======
% w: Angle in Rad
%
iconlibTL(name)- returns an icon for the use in userinterfaces
iconlibTL(name) % iconlibTL(name) - returns an icon for the use in userinterfaces
% (by Tim Lueth, VLFL-Lib, 2012-NOV-24 as class: USER INTERFACE)
%
% Generates icons for symbols such as:
% rotate3d, rotate, zoom, crosshair, hidden, pan
% To create an icon for intersion into this procedure use the following
% method:
% 1) Create an icon image file by a snapshot
% 2) use I=imreadui; to readin to cut out the desired clip, ignore scaling
% 3) use a=imresize(I,[21 21]) to resize it to 21x21 pixel
% 4) cut it the printout in the clipboard and insert it here by a name tag
% (Status of: 2013-01-16)
%
% a=iconlibTL(name)
% === INPUT PARAMETERS ===
% name: name of icaon
% === OUTPUT RESULTS ======
% a: icon matrix
%
Tcross2T(T1,T2)- returns the crossing line HT of two defined planes T1 and T2
Tcross2T(T1,T2) % Tcross2T(T1,T2) - returns the crossing line HT of two defined planes T1
% and T2
% (by Tim Lueth, HT-Lib, 2012-NOV-24 as class: ANALYTICAL GEOMETRY)
%
% if a crossing line of planes exist, it is calculated by this procedure
% (Status of: 2012-11-24)
%
% TX=Tcross2T(T1,T2)
% === INPUT PARAMETERS ===
% T1: HT matrix 1 (plane), that describes a plane by an ez-Vector and a
% position p
% T2: HT matrix 2 (plane), at describes a plane by an ez-Vector and a
% position p
% === OUTPUT RESULTS ======
% TX: HT matrix of the resulting straight line
%
% EXAMPLE: Plot the crossing line of two planes
% TX=Tcross2T (TA,TB)
% tlplot (TX,'m',50)
% [o,n]=distT(pa',TX), pla=pa'-o, pplot (pla,'r*',4)
% [o,n]=distT(pb',TX), plb=pb'-o, pplot (plb,'r*',4)
%
SGwriteSTL (O,)- Writes a STL file for a solid geometry
SGwriteSTL (O,) % SGwriteSTL (O,) - Writes a STL file for a solid geometry
% (by Tim Lueth, VLFL-Lib, 2012-NOV-24 as class: FILE HANDLING)
%
% See also: SGreadSTL, SGwriteMultipleSTL, SGwriteSeparatedSTL,
% VLFLreadSTL, VLFLwriteSTL, STLAsctoBin
%
% SGwriteSTL(O,[])
% === INPUT PARAMETERS ===
% O: Object name
%
SGchecker(SG)- performs a check of the vertex list and facet list to detect non manifold problems
SGchecker(SG) % SGchecker(SG) - performs a check of the vertex list and facet list to
% detect non manifold problems
% (by Tim Lueth, VLFL-Lib, 2012-NOV-22 as class: CHECKING PROCEDURES)
%
% This procedures generates a simple protocol on the status of the vertex
% list and facet list. It should allow to detect non manifold problems
% for generating the files and to speed up development.
% It generates an terminal output using FID=1. (Status of: 2014-11-23)
%
% [VLC,EL,PEL]=SGchecker(SG)
% === INPUT PARAMETERS ===
% SG: Vertex list of the object
% === OUTPUT RESULTS ======
% VLC: List of sorted vertices to analyze the problematic vertices
% EL: List of sorted edges to analyze the problematic edges
% PEL: List of non-manifold edges
%
% EXAMPLE: Show the non-manifold edges of a solid:
% [VLC,EL,PEL]=SGchecker(SG);
% VLFLELplot (VL,PEL);
%
deg(w)- very simple procedure to convert rad into deg
deg(w) % deg(w) - very simple procedure to convert rad into deg
% (by Tim Lueth, VLFL-Lib, 2012-NOV-21 as class: AUXILIARY PROCEDURES)
%
% see also rad (Status of: 2013-08-15)
%
% dw=deg(w)
% === INPUT PARAMETERS ===
% w: Angle in Rad
% === OUTPUT RESULTS ======
% dw: Angle in Deg
%
SGplot(SG,c,w,T,N)- plots a solid geometry
SGplot(SG,c,w,T,N) % SGplot(SG,c,w,T,N) - plots a solid geometry
% (by Tim Lueth, VLFL-Lib, 2012-NOV-21 as class: VISUALIZATION)
%
% Works with structure SG and cells of structures (SG1, SG2, ...}. Uses
% SG.VL, Vertex list
% SG.FL, Facet list
% SG.col (optional) Color
% SG.alpha (optional) Tansparancy
% (Status of: 2017-02-08)
%
% See also: VLFLplot, TRplot, VLTLplot, VLFLplot4
%
% h=SGplot(SG,[c,w,T,N])
% === INPUT PARAMETERS ===
% SG: Solid Geometry Structure
% c: Color; Option for VLFLplot
% w: Width; Option for VLFLplot
% T: optional HT matrix
% N: optional Name of Coordinate System
% === OUTPUT RESULTS ======
% h: handle to figure
%
% EXAMPLE: SGplot (SG1,'r')
% SGplot ({SG1,SG2,SG3},'m')
%
exp_2012_11_22- EXPERIMENT to test different methods to link two solids
exp_2012_11_22 % exp_2012_11_22 - EXPERIMENT to test different methods to link two solids
% (by Tim Lueth, VLFL-Lib, 2012-NOV-21 as class: EXPERIMENTS)
%
% exp_2012_11_22
%
% EXAMPLE: exp_2012_11_22
%
SGlinkwall(SGA,n1,dist,sz,sx,sy)- returns a solid geometry of a plain wall and attaches it to a solid geometry
SGlinkwall(SGA,n1,dist,sz,sx,sy) % SGlinkwall(SGA,n1,dist,sz,sx,sy) - returns a solid geometry of a plain
% wall and attaches it to a solid geometry
% (by Tim Lueth, VLFL-Lib, 2012-NOV-18 as class: SYNTHESIZING PROCEDURES)
%
% This procedure uses TofVLULez to find a corresponding union of the
% body. If it fails, no wall, nor attachment will be generated (Status
% of: 2013-01-18)
%
% SGW=SGlinkwall(SGA,n1,dist,sz,sx,sy)
% === INPUT PARAMETERS ===
% SGA: Solid geometry that should get a wall
% n1: ez vector points into the wall direction
% dist: distance, the wall should be created
% sz: depth of the wall
% sx: size in x
% sy: size in y
% === OUTPUT RESULTS ======
% SGW: Solid geometry of wall and linking structure
%
FLofVLEL2(VL,EL)- returns the facet list for a vertex list and a planar edge list in 3D
FLofVLEL2(VL,EL) % FLofVLEL2(VL,EL) - returns the facet list for a vertex list and a
% planar edge list in 3D
% (by Tim Lueth, VLFL-Lib, 2012-NOV-17 as class: AUXILIARY PROCEDURES)
%
% Similiar to FLofVLEL, using delaunayTri, bit in addition the contour is
% decomposed in facet with same normal vectors. The result is much better
% than FLofVLEL/Delaunaytri, if enough vertices are used.
% Use FLofVLEL2 (VL,EL) for optimal results
% Use FLofVLEL (VL,EL) for delaunay results
% Use FLofVL for quick and dirty results
% (Status of: 2012-11-17)
%
% FL=FLofVLEL2(VL,EL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% EL: Edge list
% === OUTPUT RESULTS ======
% FL: Facet list
%
SGlinkstraight(SGA,SGB,TA,TB,CL,ELU,nf)- returns a solid link between TA and TB
SGlinkstraight(SGA,SGB,TA,TB,CL,ELU,nf) % SGlinkstraight(SGA,SGB,TA,TB,CL,ELU,nf) - returns a solid link between
% TA and TB
% (by Tim Lueth, VLFL-Lib, 2012-NOV-16 as class: SYNTHESIZING PROCEDURES)
%
% The vertex contains first the vertices at Solid A and the the vertices
% of solid B. The Facet list contains first the facets of the wall
% (2*nv), and then the facets of the cap on Side A and then the cap on
% side B. compiled from experiment exp_2012_11_12 and used in
% exp_2012_11_15. (Status of: 2013-01-18)
%
% [SGlink,nv]=SGlinkstraight(SGA,SGB,[TA,TB,CL,ELU,nf])
% === INPUT PARAMETERS ===
% SGA: Solid A
% SGB: Solid B
% TA: HT Matrix for A
% TB: HT Matrix for B; Typical A+n*ez;
% CL: Contour list; default is a Radius 5
% ELU: Edge list for Contour; default is a wallsize 2
% nf: number of facets; default is 4;
% === OUTPUT RESULTS ======
% SGlink: Vertex list
% nv: Facet list
%
exp_2012_11_15 (dist)- EXPERIMENT to show how to automatically generate housing walls for objects in cube style
exp_2012_11_15 (dist) % exp_2012_11_15 (dist) - EXPERIMENT to show how to automatically
% generate housing walls for objects in cube style
% (by Tim Lueth, VLFL-Lib, 2012-NOV-15 as class: EXPERIMENTS)
%
% The procedures FTlinkwall and FTlinkstraight were generated for this
% experiment (Status of: 2012-11-20)
%
% exp_2012_11_15([dist])
% === INPUT PARAMETERS ===
% dist: distance of the walls to the body
%
% EXAMPLE: Build walls around a tube to generate a housing
% exp_2012_11_15 (0)
%
VLFLboxT(T,sz,sx,sy,dz,R)- returns a box at a predefined position
VLFLboxT(T,sz,sx,sy,dz,R) % VLFLboxT(T,sz,sx,sy,dz,R) - returns a box at a predefined position
% (by Tim Lueth, VLFL-Lib, 2012-NOV-15 as class: SYNTHESIZING PROCEDURES)
%
% The procedure is used to generate automatically housings for objects or
% flange plates (Status of: 2012-11-16)
%
% [VL,FL]=VLFLboxT(T,[sz,sx,sy,dz,R])
% === INPUT PARAMETERS ===
% T: Transformation
% sz: size in z, default is 1
% sx: size in x, default is 10
% sy: size in y, default is sx
% dz: position change in -z, default is 0.01
% R: radius of hole in the plate to remove SLS-Material
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
exp_2012_11_14- Experiment that shows how contours are closed
exp_2012_11_14 % exp_2012_11_14 - Experiment that shows how contours are closed
% (by Tim Lueth, VLFL-Lib, 2012-NOV-14 as class: EXPERIMENTS)
%
% The contours are closed using
% [CEL,CIL,nme]=CLdecomposecontoursVLCL(PLE,CEL,CIL); and
% FL=FLclosecontoursVLCL (PLE,CEL,CIL); (Status of: 2012-11-15)
%
% exp_2012_11_14
%
VLofimage_2012b(I,pixsize,h)- converts an image into a contour or a solid
VLofimage_2012b(I,pixsize,h) % VLofimage_2012b(I,pixsize,h) - converts an image into a contour or a solid
% (by Tim Lueth, VLFL-Lib, 2012-NOV-12 as class: TEXT PROCEDURES)
%
% There is a newer version of this fnctn. This fnctn will be discontinued.
% Quite useful procedure to generate contours from images or string
% comments in combination with imageoftext. If parameter h>0, the fnctn
% returns a solid.
% In May 2014, ELconnectEL has been exchanged by ELreconnectEL (much
% slower but correct)
% This fnctn is just a little bit slower than the contour fnctn of Matlab
% (Status of: 2017-03-17)
%
% See also: CPLtextimage, VLFLtextimage, imageoftext, VLofimage
%
% [VL,EL,FL]=VLofimage_2012b(I,[pixsize,h])
% === INPUT PARAMETERS ===
% I: image array
% pixsize: size of a pixel
% h: desired heigth; default is 0 (Contour)
% === OUTPUT RESULTS ======
% VL: Vertex list (nx2) for h=0; (nx3) for h>0;
% EL: Edge list
% FL: Facet list
%
% EXAMPLE: Generate a contour for the string 'Test':
% I=imageoftext('TL:MMXII-XI-XII',36);
% [VL,EL,FL]=VLofimage(I,.7); VLELplot(VLaddz(VL),EL,'r-')
% [VL,EL,FL]=VLofimage(I,.7,3); close all, VLFLplot(VL,FL),
%
slcplotVLFL (VL,FL,n);- plots the slices of a sliced solid geoemtry
slcplotVLFL (VL,FL,n); % slcplotVLFL (VL,FL,n); - plots the slices of a sliced solid geoemtry
% (by Tim Lueth, VLFL-Lib, 2012-NOV-12 as class: ANALYZING PROCEDURES)
%
% =======================================================================
% OBSOLETE (2017-03-20) - USE FAMILY 'CPLofSGslice' INSTEAD
% =======================================================================
%
% This fnctn is used to check slicer fnctns such as VLELslicer or
% VLELslicer2.
% Pure slicing as a cross plane cut is simpler than slicing similar to a
% volumetric slice generation, that includes also effects between the
% cutting plane. (Status of: 2017-03-20)
%
% See also: [ CPLofSGslice ] ; slcplotVLFL, VLELslicer
%
% slcplotVLFL(VL,FL,[n]);
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% n:
%
% EXAMPLE: [VL,FL]=exp_2013_08_14;
% slcplotVLFL (VL,FL,5)
%
exp_2012_11_11_03 (nf,d,ezd,cn)- EXPERIMENT similar to exp_2012_11_01_2 for generating a STL of a colon segment but this time as mesh
exp_2012_11_11_03 (nf,d,ezd,cn) % exp_2012_11_11_03 (nf,d,ezd,cn) - EXPERIMENT similar to
% exp_2012_11_01_2 for generating a STL of a colon segment but this time
% as mesh
% (by Tim Lueth, VLFL-Lib, 2012-NOV-11 as class: EXPERIMENTS)
%
% Produces a colon, which is a tube with a sinus curve waisted outer and
% inner diameter.
% Similar to exp_2012_11_01_2 (Status of: 2012-11-11)
%
% exp_2012_11_11_03([nf,d,ezd,cn])
% === INPUT PARAMETERS ===
% nf: number of facets of the tube; default is nofrd
% d: diameter of the tubel; default is 40
% ezd: direction of the flange give by 'i','ii' usw.
% cn: number of step between start and end (-2); default 40
%
% EXAMPLE: show different colon meshes (not weaved)
% exp_2012_11_11_03 (20,nan,'V',20)
% exp_2012_11_11_03 (40,nan,'V',40)
% exp_2012_11_11_03 (60,nan,'V',60)
% exp_2012_11_11_03 (80,nan,'V',80)
%
%
exp_2012_11_12 (nf,d,ezd,cn)- EXPERIMENT similar to exp_2012_11_11_03 but this time generates a mesh robot link
exp_2012_11_12 (nf,d,ezd,cn) % exp_2012_11_12 (nf,d,ezd,cn) - EXPERIMENT similar to exp_2012_11_11_03
% but this time generates a mesh robot link
% (by Tim Lueth, VLFL-Lib, 2012-NOV-11 as class: EXPERIMENTS)
%
% Produces a colon, which is a tube with a sinus curve waisted outer and
% inner diameter.
% Similar to exp_2012_11_01_2 (Status of: 2012-11-12)
%
% exp_2012_11_12([nf,d,ezd,cn])
% === INPUT PARAMETERS ===
% nf: number of facets of the tube; default is nofrd
% d: diameter of the tubel; default is 40
% ezd: direction of the flange give by 'i','ii' usw.
% cn: number of step between start and end (-2); default 40
%
% EXAMPLE: show different colon meshes (not weaved)
% exp_2012_11_12 (20,nan,'V',20)
% exp_2012_11_12 (40,nan,'V',40)
% exp_2012_11_12 (60,nan,'V',60)
% exp_2012_11_12 (80,nan,'V',80)
%
%
imageoftext(line,siz,col,ha)- returns a binar matrix and an image matrix for a text string
imageoftext(line,siz,col,ha) % imageoftext(line,siz,col,ha) - returns a binar matrix and an image
% matrix for a text string
% (by Tim Lueth, VLFL-Lib, 2012-NOV-10 as class: TEXT PROCEDURES)
%
% This procedure can be used to generate button images from text string.
% It can be also used for converting text into a solid geometry.
% (Status of: 2014-12-26)
%
% [I,C,n]=imageoftext(line,[siz,col,ha])
% === INPUT PARAMETERS ===
% line: text string
% siz: Size, default is 10 point
% col: Gray scale, default is 204
% ha: 'l','c','r'; default is 'l'
% === OUTPUT RESULTS ======
% I: Binary matrix
% C: Color image
% n: number of lines found
%
% EXAMPLE: Convert a latex-String:
% [I,C]=imageoftext ('\ite^{\omega\tau} ',40); image(C)
% [I,C]=imageoftext ('TEST',40); image(C)
%
exp_2012_11_10 (k,n2,d)- Experiment to generate Bezier Tubes by surface Bezier curves
exp_2012_11_10 (k,n2,d) % exp_2012_11_10 (k,n2,d) - Experiment to generate Bezier Tubes by
% surface Bezier curves
% (by Tim Lueth, VLFL-Lib, 2012-NOV-10 as class: EXPERIMENTS)
%
% This is a simple experiment to understand that it is not possible to
% generate tubes simple by surface bezier curves instead of central
% bezier curves (Status of: 2012-11-11)
%
% exp_2012_11_10([k,n2,d])
% === INPUT PARAMETERS ===
% k: bending radius
% n2: diameter
% d: normal vector of point 2
%
% EXAMPLE: Compare different curves
% exp_2012_11_10
% exp_2012_11_10 (4)
% exp_2012_11_10 (4,[1 0 0])
%
VLFLfigure()- Application for opening and viewing STL Files
VLFLfigure() % VLFLfigure() - Application for opening and viewing STL Files
% (by Tim Lueth, VLFL-Lib, 2012-NOV-09 as class: VISUALIZATION)
%
% The procedure can be compiled as application or used as user interface
% procedure. Called without input parameters, a file reading dialog will
% be opened. There are examples for reading, writing of STL files and
% changing light condition or grid information.
% It should show the potential of Matlab to the company Arburg, Lossburg
% (Status of: 2013-08-14)
%
% [hf,hm,ht,htt]=VLFLfigure([])
% === OUTPUT RESULTS ======
% hf: handle to figure
% hm: handle to menu
% ht: handle to toolbar
% htt: handle to button 1
%
% EXAMPLE: GUI with a small cube (0.1 0.1 0.1) in the center:
% VLFLfigure
%
app_2012_11_09(SG,SG.FL,xcol)- Application for opening and viewing STL Files
app_2012_11_09(SG,SG.FL,xcol) % app_2012_11_09(SG,SG.FL,xcol) - Application for opening and viewing STL
% Files
% (by Tim Lueth, VLFL-Lib, 2012-NOV-09 as class: APPLICATION)
%
% The procedure can be compiled as application or used as user interface
% procedure. Called without input parameters, a file reading dialog will
% be opened. There are examples for reading, writing of STL files and
% changing light condition or grid information.
% It should show the potential of Matlab to the company Arburg, Lossburg
% (Status of: 2013-04-25)
%
% [hf,hm,ht,htt]=app_2012_11_09([SG,SG.FL,xcol])
% === INPUT PARAMETERS ===
% SG: Vertex list of solid geometry
% SG.FL: Facet list of solid geometry
% xcol:
% === OUTPUT RESULTS ======
% hf: handle to figure
% hm: handle to menu
% ht: handle to toolbar
% htt: handle to button 1
%
% EXAMPLE: GUI with a small cube (0.1 0.1 0.1) in the center:
% app_2012_11_09 ([]);
%
exp_2012_11_08- EXPERIMENT to design a robot kinematic automatically
exp_2012_11_08 % exp_2012_11_08 - EXPERIMENT to design a robot kinematic automatically
% (by Tim Lueth, VLFL-Lib, 2012-NOV-08 as class: EXPERIMENTS)
%
% ..for Dr.-Ing. Franz Irlinger.. (Status of: 2012-11-08)
%
% exp_2012_11_08
%
depfunTL_2014b(fname,par)- returns all dependency files of a function that are not part of a toolbox
depfunTL_2014b(fname,par) % depfunTL_2014b(fname,par) - returns all dependency files of a fnctn that are not part of a toolbox
% (by Tim Lueth, VLFL-Lib, 2012-NOV-08 as class: AUXILIARY PROCEDURES)
%
% =======================================================================
% OBSOLETE (2017-03-25) - USE FAMILY 'depfunTL' INSTEAD
% =======================================================================
%
% replaces depfun ('fnctnname'), which without '-toponly' seems to be
% instable in 2012b
% depfunTL shows all procedures that are used in a procedure
% depuseTL shows all procedures that uses a named procedure
%
% Will be replaced by
% a=matlab.codetools.requiredFilesAndProducts('exp_2015_09_30')
%
% (Status of: 2017-03-25)
%
% See also: [ depfunTL ] ; depfunTL
%
% [PL,ML]=depfunTL_2014b(fname,[par])
% === INPUT PARAMETERS ===
% fname: fnctn name
% par: parameter such as '-toponly'
% === OUTPUT RESULTS ======
% PL: List of private fnctns
% ML: List of matlab fnctns
%
% EXAMPLE: Depency files of FTelement.m
% depfunTL ('FTelement')
%
%
immeasureui- user interface to measure distances within an image using mouse clicks
immeasureui % immeasureui - user interface to measure distances within an image using
% mouse clicks
% (by Tim Lueth, VLFL-Lib, 2012-NOV-07 as class: USER INTERFACE)
%
% immeasureui
%
% EXAMPLE: Just try
% immeasureui
%
pcodeTL_2014b(fname,tag);- exports know functions that are not part of toolboxes into pcode
pcodeTL_2014b(fname,tag); % pcodeTL_2014b(fname,tag); - exports know fnctns that are not part of toolboxes into pcode
% (by Tim Lueth, VLFL-Lib, 2012-NOV-06 as class: FILE HANDLING)
%
% pcodeTL_2014b is the original fnctn used 2012-2016 (last version 2014b)
% This is an important fnctn for the generation of intellectual property
% protected code
% pcodeTL() generates pcode files plus help text for
% pcodeTL(,'public') generates pcode plus the unprotected m-file
% pcodeTL(,'hidden') generates only pcode files without any help
% (Status of: 2016-06-06)
%
% varargout=pcodeTL_2014b(fname,[tag]);
% === INPUT PARAMETERS ===
% fname: Name of matlab fnctn in the search path
% tag: optional, 'hidden' does not show
% === OUTPUT RESULTS ======
% [PL]:
% [ML]:
%
% EXAMPLE: Generate pcode of fnctn FTElements and add all required
% procedures
% pcodeTL('VLFLplot')
% pcodeTL('VLFLplot','hidden')
% pcodeTL('VLFLplot','public')
%
pcodeTL(fname,tag);- exports functions into pcode to create toolboxes
pcodeTL(fname,tag); % pcodeTL(fname,tag); - exports fnctns into pcode to create toolboxes
% (by Tim Lueth, VLFL-Lib, 2012-NOV-06 as class: FILE HANDLING)
%
% This fnctn is comptabile with 2016a and does nut use depfun anymore
% This is an important fnctn for the generation of intellectual property
% protected code
% pcodeTL() generates pcode files plus help text for
% pcodeTL(,'public') generates pcode plus the unprotected m-file
% pcodeTL(,'hidden') generates only pcode files without any help
% (Status of: 2017-01-03)
%
% See also: publishTL, depfunTL, depuseTL, depuseString
%
% varargout=pcodeTL(fname,[tag]);
% === INPUT PARAMETERS ===
% fname: Name of matlab fnctn in the search path
% tag: optional, 'hidden' does not show
% === OUTPUT RESULTS ======
% [PL]: Prodecure list by Developer
% [ML]: Matlab procedure list
%
% EXAMPLE: Generate pcode of fnctn FTElements and add all required
% procedures
% pcodeTL('VLFLplot')
% pcodeTL('VLFLplot','hidden')
% pcodeTL('VLFLplot','public')
%
imreadui(fname,clip)- reads an image file and opens dialogs to clip and scale the image
imreadui(fname,clip) % imreadui(fname,clip) - reads an image file and opens dialogs to clip
% and scale the image
% (by Tim Lueth, VLFL-Lib, 2012-NOV-05 as class: USER INTERFACE)
%
% This procedure has been developed for measure features in gears
% pictures (Status of: 2012-11-06)
%
% [I,ax]=imreadui([fname,clip])
% === INPUT PARAMETERS ===
% fname: filename optional; default is user request
% clip: clipping frame; default is user selection
% === OUTPUT RESULTS ======
% I: Clipped Image
% ax: Axes of the clipped and caled image
%
% EXAMPLE: Just try different parameter use:
% [I,ax]=imreadui;
% [I,ax]=imreadui('FUTABA1.JPG');
% [I,ax]=imreadui('FUTABA1.JPG',[152 578 235 617]);
%
VMuidicom(filename)- reads in a dicom file or opens a dialog first
VMuidicom(filename) % VMuidicom(filename) - reads in a dicom file or opens a dialog first
% (by Tim Lueth, VLFL-Lib, 2012-NOV-05 as class: VOXELS)
%
% If no file name for the current working directory is set, a dialog is
% opened.
% For full information on the dicom format read:
% http://medical.nema.org/Dicom/2011/11_03pu.pdf (Status of: 2017-02-16)
%
% See also: VM, VMimage, VMimrot90, VMmontage, VMplot, VMpseudo3D,
% VMreaddicom, VMreaddicomdir
%
% [X,tags]=VMuidicom([filename])
% === INPUT PARAMETERS ===
% filename: optional filename
% === OUTPUT RESULTS ======
% X: voxel model of dicom stack
% tags: empty, if no dicom file
%
CLdecomposecontoursVLCL(VL,AMELS,CIL)- decomposes missing edges from open facets of a solid
CLdecomposecontoursVLCL(VL,AMELS,CIL) % CLdecomposecontoursVLCL(VL,AMELS,CIL) - decomposes missing edges from
% open facets of a solid
% (by Tim Lueth, VLFL-Lib, 2012-NOV-03 as class: ANALYZING PROCEDURES)
%
% This procedure is required after find open facets using
% CLmissingedgesVLFL (edges are only used in one direction), that links
% the open edges to contours. If there exist a contour that is not
% planar, this procedure decomposes the 3D contours in a set of planar
% contours by adding edges without(!) adding vertex points. So, this
% procedure decomposes one contours into several contours that have the
% same normal vector.The procedure works quite well and stable. (Status
% of: 2012-11-14)
%
% [AMELS,CIL,nme]=CLdecomposecontoursVLCL(VL,AMELS,CIL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% AMELS: All missing edge list sorted
% CIL: Contour index list
% === OUTPUT RESULTS ======
% AMELS: All missing edge list sorted and decomposed
% CIL: Contour index list
% nme: Number of Contours
%
CLmissingedgesVLFL(VL,FL)- returns missing edges of open facets
CLmissingedgesVLFL(VL,FL) % CLmissingedgesVLFL(VL,FL) - returns missing edges of open facets
% (by Tim Lueth, VLFL-Lib, 2012-NOV-03 as class: ANALYZING PROCEDURES)
%
% This procedure is used to find and close open facets by analyzing
% missing edges. It finds edges that are used only in one direction and
% not in the opposite direction. For those, the missing edges in opposite
% direction are generated here. The edges are linked to contours to be
% processed one by one afterwards. CLdecomposecontoursVLCL separates the
% contours which are not planar in planar contours. (Status of:
% 2012-11-04)
%
% [MEL,CIL,n]=CLmissingedgesVLFL(VL,FL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% === OUTPUT RESULTS ======
% MEL: Missing edge list
% CIL: Contour index list (COL 1: start index, COL2: end index)
% n: size(CIL,1)
%
% EXAMPLE: Simple Box
% [VL,FL]=VLFLbox(10,10,10); % Generate Box
% FL=FL(1:end-4,:); % Remove 4 Facets
% [AMELS,CIL,nme]=CLmissingedgesVLFL (VL,FL); % Search for missing edges
% VLELplot (VL,AMELS,'m'); % plot the missing edges
%
exp_2012_11_3_1 (i,j)- EXPERIMENT to show the difference of FLofVLEL and FLclosecontoursVLCL
exp_2012_11_3_1 (i,j) % exp_2012_11_3_1 (i,j) - EXPERIMENT to show the difference of FLofVLEL
% and FLclosecontoursVLCL
% (by Tim Lueth, VLFL-Lib, 2012-NOV-03 as class: EXPERIMENTS)
%
% While FLofVLEL uses DelaunayTri, the procedure FLclosecontoursVLCL does
% no try to generate convex hulls, but to maximize the surface by using
% planar planes. In case of DelaunayTri/FLofVLEL, the resulting facets
% depend on the ordner of points. It means, the same contour with the
% same point in the same order but with a different starting point can
% easily deliver a different result using DelaunayTri.
% CLdecomposecontoursVLCL in combination with FLclosecontoursVLCL will
% have always a determined result (Status of: 2012-11-14)
%
% exp_2012_11_3_1([i,j])
% === INPUT PARAMETERS ===
% i: raised edge of the 7-gon; default is 4
% j: raised edge of the 7-gon; default is i
%
FLclosecontoursVLCL(VL,AMELS,CIL)- returns for a contour list the facet list
FLclosecontoursVLCL(VL,AMELS,CIL) % FLclosecontoursVLCL(VL,AMELS,CIL) - returns for a contour list the
% facet list
% (by Tim Lueth, VLFL-Lib, 2012-NOV-03 as class: SYNTHESIZING PROCEDURES)
%
% After calling CLmissingedgesVLFL and CLdecomposecontoursVLCL this
% procedure is the 3rd step to close the individual contours which have
% the same normal vector (Status of: 2012-11-04)
%
% FL=FLclosecontoursVLCL(VL,AMELS,CIL)
% === INPUT PARAMETERS ===
% VL: Vertex list
% AMELS: All missing edge list sorted
% CIL: Contour index list
% === OUTPUT RESULTS ======
% FL: Facet list
%
exp_2012_11_03 (rf,sf)- EXPERIMENT to analyze and repair open surfaces
exp_2012_11_03 (rf,sf) % exp_2012_11_03 (rf,sf) - EXPERIMENT to analyze and repair open surfaces
% (by Tim Lueth, VLFL-Lib, 2012-NOV-03 as class: EXPERIMENTS)
%
% Based on a remark of Daniel Roppenecker, an experiment was started to
% detect an close open contours in a solid surface.
% 1. Step: Find all edges which exist in only one direction
% 2. Step: Order and link the edges to closed contours
% 3. Step: Separate a Contour if not all points are in the same plane
% 4. Step: Generate the facets for the contours of the same normal vector
% (Status of: 2012-11-14)
%
% exp_2012_11_03([rf,sf])
% === INPUT PARAMETERS ===
% rf: how many facets should be removed; default 1
% sf: which is the first removed one; default 0
%
VLFLtextattachVLUL(VL,UL,ez,atext,sx,sy)- returns a string as VLFL list positioned at the center of a specified union
VLFLtextattachVLUL(VL,UL,ez,atext,sx,sy) % VLFLtextattachVLUL(VL,UL,ez,atext,sx,sy) - returns a string as VLFL
% list positioned at the center of a specified union
% (by Tim Lueth, VLFL-Lib, 2012-NOV-01 as class: SYNTHESIZING PROCEDURES)
%
% very helpful procedure to automatically attach text solids on objects
% (Status of: 2013-01-12)
%
% [TVL,TFL,ui]=VLFLtextattachVLUL(VL,UL,ez,atext,[sx,sy])
% === INPUT PARAMETERS ===
% VL: Vertex list
% UL: Union list
% ez: desired ez vector
% atext: desired text string
% sx: desired size in x
% sy: desired size in y
% === OUTPUT RESULTS ======
% TVL: Text vertex list
% TFL: text facet list
% ui: union index of the selected union
%
exp_2012_11_01_2(nf,d,ezd)- EXPERIMENT for generating a STL of a colon segment
exp_2012_11_01_2(nf,d,ezd) % exp_2012_11_01_2(nf,d,ezd) - EXPERIMENT for generating a STL of a colon
% segment
% (by Tim Lueth, VLFL-Lib, 2012-NOV-01 as class: EXPERIMENTS)
%
% Produces a colon, which is a tube with a sinus curve waisted outer and
% inner diameter.
%
% [VL,FL]=exp_2012_11_01_2([nf,d,ezd])
% === INPUT PARAMETERS ===
% nf: number of facets of the tube; default is nofrd
% d: diameter of the tubel; default is 40
% ezd: direction of the flange give by 'i','ii' usw.
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: exp_2012_11_01_2 (nan,nan,'i')
%
exp_2012_11_01(nf,d,atext,ezd)- EXPERIMENT similar to EXP_2012_10_31 for automatic connection of two solids
exp_2012_11_01(nf,d,atext,ezd) % exp_2012_11_01(nf,d,atext,ezd) - EXPERIMENT similar to EXP_2012_10_31
% for automatic connection of two solids
% (by Tim Lueth, VLFL-Lib, 2012-NOV-01 as class: EXPERIMENTS)
%
% This experiment shows how to automatically connecting two solids by a
% bar. The STL of the bar and the STL of the two linked solids are
% written as file on disk. (Status of: 2012-11-04)
%
% [VL,FL]=exp_2012_11_01([nf,d,atext,ezd])
% === INPUT PARAMETERS ===
% nf: number of facets of the connector, default is automatic
% d: Facet list of the wall
% atext: text string
% ezd: char index to describe the desired ez vector
% === OUTPUT RESULTS ======
% VL: Vertex list of the wall
% FL: Facet list of the wall
%
VLFLpprojectPLEL(PL,ELU,ez,VL,FL,diffuse)- returns the surface of a parallel projection of a contour
VLFLpprojectPLEL(PL,ELU,ez,VL,FL,diffuse) % VLFLpprojectPLEL(PL,ELU,ez,VL,FL,diffuse) - returns the surface of a parallel projection of a contour
% (by Tim Lueth, VLFL-Lib, 2012-NOV-01 as class: SYNTHESIZING PROCEDURES)
%
% Improved Version of VLFLpprojectPL. This fnctns was originally created
% to create "adaptors" between a tube and a solid. (Status of: 2017-04-01)
%
% See also: VLFLpprojectPL, VLprojection
%
% [VL,FL,PLP,PLE,FLCS,FLCE]=VLFLpprojectPLEL(PL,ELU,ez,VL,FL,[diffuse])
% === INPUT PARAMETERS ===
% PL: Point list to describe a contour
% ELU: Edge list of the projected contour
% ez: direction of the parallel projection
% VL: Vertex list of a solid
% FL: Facet list of a solid
% diffuse: length to intrude into the body
% === OUTPUT RESULTS ======
% VL: Vertex list of the
% FL: Facet list
% PLP: Supplemented contour
% PLE: Supplemented and recalculated contour
% FLCS: Start cap to close the FL on the start contour side
% FLCE: End cap to close the FL on the end contour side
%
FTcontour- returns half profile of Fischertechnik dove tail contour
FTcontour % FTcontour - returns half profile of Fischertechnik dove tail contour
% (by Tim Lueth, VLFL-Lib, 2012-NOV-01 as class: AUXILIARY PROCEDURES)
%
% Quick and Dirty, used in FTgearframe (Status of: 2016-12-28)
%
% See also: FTelement, FTclutch, FTjacoringOL, FTjacoringIL, FTgearcase,
% FTgearframe
%
% PL=FTcontour
% === OUTPUT RESULTS ======
% PL: Point list of dove tail contour
%
FTgearframe- returns an solid for a Fischertechnik gear box motor
FTgearframe % FTgearframe - returns an solid for a Fischertechnik gear box motor
% (by Tim Lueth, VLFL-Lib, 2012-NOV-01 as class: SYNTHESIZING PROCEDURES)
%
% See also: FTelement, FTclutch, FTjacoringOL, FTjacoringIL, FTgearcase,
% FTcontour
%
% C=FTgearframe
% === OUTPUT RESULTS ======
% C: Solid object
%
% EXAMPLE: Show the gear frame:
% F=FTgearframe; plotFT (F);
%
exp_2012_11_02(nf,d,ezd)- EXPERIMENT for generating bezier tube elements
exp_2012_11_02(nf,d,ezd) % exp_2012_11_02(nf,d,ezd) - EXPERIMENT for generating bezier tube
% elements
% (by Tim Lueth, VLFL-Lib, 2012-NOV-01 as class: EXPERIMENTS)
%
% Originally started to design a colon, the similiarity to a JACO robot
% arm segment became obvious. The procedure uses ezofchar to specify the
% conccetion point to a unvisible box.
%
% [VL,FL]=exp_2012_11_02([nf,d,ezd])
% === INPUT PARAMETERS ===
% nf: number of facets of the tube; default is nofrd
% d: diameter of the tubel; default is 40
% ezd: direction of the flange give by 'i','ii' usw.
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: exp_2012_11_02 (nan,nan,nan,'i')
%
exp_2012_10_31(nf,d)- Experiment for automatic connection of two solids
exp_2012_10_31(nf,d) % exp_2012_10_31(nf,d) - Experiment for automatic connection of two solids
% (by Tim Lueth, VLFL-Lib, 2012-OKT-31 as class: EXPERIMENTS)
%
% IMPROVED VERSION OF EXP_2012_10_27;
% This experiment shows how to automatically connecting two solids by a
% bar. The STL of the bar and the STL of the two linked solids are
% written as file on disk. (Documented: 2012-10-31)
%
% [VL,FL]=exp_2012_10_31([nf,d])
% === INPUT PARAMETERS ===
% nf: number of facets of the connector, default is automatic
% d: diameter/radius of the connector, defautl is 4
% === OUTPUT RESULTS ======
% VL: Vertex list of the wall
% FL: Facet list of the wall
%
% EXAMPLE: Simply type exp_2012_10_27
%
VLFLring(r,n,h,w)- returns vertex list and facet list of a ring
VLFLring(r,n,h,w) % VLFLring(r,n,h,w) - returns vertex list and facet list of a ring
% (by Tim Lueth, VLFL-Lib, 2012-OKT-31 as class: SYNTHESIZING PROCEDURES)
%
% [VL,FL]=VLFLring([r,n,h,w])
% === INPUT PARAMETERS ===
% r: Radius of the ring; default is 10
% n: number of facets; default is nofrd
% h: height of the ring
% w: width of the ring; default is r/2
% === OUTPUT RESULTS ======
% VL: Vertex list of the ring
% FL: Facet list of the ring
%
FLofVLEL(PL,EL)- returns the facet list for a vertex list and a planar edge list in 3D
FLofVLEL(PL,EL) % FLofVLEL(PL,EL) - returns the facet list for a vertex list and a planar
% edge list in 3D
% (by Tim Lueth, VLFL-Lib, 2012-OKT-31 as class: AUXILIARY PROCEDURES)
%
% similiar to DelaunayTri, but in combination with cartotobaryVL, it is
% usable for 3D Contours. (Status of: 2012-11-03)
%
% FL=FLofVLEL(PL,EL)
% === INPUT PARAMETERS ===
% PL: Vertex list
% EL: Edge list
% === OUTPUT RESULTS ======
% FL: Facet list
%
exp_2012_10_31_2- EXPERIMENT that shows the use of FLofVLFL
exp_2012_10_31_2 % exp_2012_10_31_2 - EXPERIMENT that shows the use of FLofVLFL
% (by Tim Lueth, VLFL-Lib, 2012-OKT-31 as class: EXPERIMENTS)
%
% exp_2012_10_31_2
%
% EXAMPLE: Simply type exp_2012_10_31_2
%
exp_2012_10_28(m,z,z2,n,rsp,x)- EXPERIMENT showing two gears
exp_2012_10_28(m,z,z2,n,rsp,x) % exp_2012_10_28(m,z,z2,n,rsp,x) - EXPERIMENT showing two gears
% (by Tim Lueth, VLFL-Lib, 2012-OKT-28 as class: EXPERIMENTS)
%
% [PL,d1,dk]=exp_2012_10_28([m,z,z2,n,rsp,x])
% === INPUT PARAMETERS ===
% m: modul (d=z*m); default is 1.25
% z: number of teeth; default is 48
% z2: number of teeth; default is 40
% n: number of nodes per flank; default is 5
% rsp: ratio of tooth footh width to modul, default is 0.7
% x: strech factor for tooth size;
% === OUTPUT RESULTS ======
% PL: Point list
% d1: maximum diameter
% dk: rolling circle diameter
%
% EXAMPLE: Show two gears, z=48, m=1.25 ==> d=60;
% [PL,d,dk]=exp_2012_10_28(0.5,30,38);
%
PLgearDIN(m,z,gap,tig,n,rsp,x)- returns a gear contour wrt DIN
PLgearDIN(m,z,gap,tig,n,rsp,x) % PLgearDIN(m,z,gap,tig,n,rsp,x) - returns a gear contour wrt DIN
% (by Tim Lueth, VLFL-Lib, 2012-OKT-28 as class: SYNTHESIZING PROCEDURES)
%
% still work in progress
% d=z*m;
% (Status of: 2015-10-02)
%
% See also: PLcircle, PLcircseg, PLevolvente, PLhelix, PLkidney, PLrand,
% PLspiral, PLsquare, PLstar
%
% [PLall,d,dk,df,r]=PLgearDIN([m,z,gap,tig,n,rsp,x])
% === INPUT PARAMETERS ===
% m: modul; negative means internal gear
% z: Teeth number
% gap: Thickness of 2nd contour; default is 0;
% tig: starting orientation (=gap, 1=tooth)
% n: number of nodes per flank; default 5
% rsp: Ratio of footh width to modul size; default is 0.7
% x: strech factor; default is 1
% === OUTPUT RESULTS ======
% PLall: Point list (2D)
% d: rolling circle
% dk: head diameter
% df: foot diameter
% r: radius of 2nd contour
%
% EXAMPLE: Draw a gear with module 1 and 20 teeth (i.e. d=zm, i.e. 20 mm)
% closeall; hold on, [PL,d,dk,df]=PLgearDIN(-2.3,21,0,5,0.75,1);
% pplot (PL','b-'), pplot (PLcircle(d/2)','r'),
% pplot (PLcircle(df/2)','m'), pplot (PLcircle(dk/2)','g'),axis equal,
% view (0,90)
%
%
PLsupplement(PL)- returns a given contour including supplemented points
PLsupplement(PL) % PLsupplement(PL) - returns a given contour including supplemented points
% (by Tim Lueth, VLFL-Lib, 2012-OKT-27 as class: AUXILIARY PROCEDURES)
%
% When a structure with a given contour is parallel projected onto the
% surfaces of an solid, sometimes a points of the parallel projected
% contour do no hit the surface. In this case a contour list has missing
% points given as [inf inf inf]. PLsupplement interpolates between the
% existing points.
%
% [PL,nsup]=PLsupplement(PL)
% === INPUT PARAMETERS ===
% PL: Point list with missing points given as [inf inf inf]
% === OUTPUT RESULTS ======
% PL: Point list with interpolated points
% nsup: Number of interpolated / supplemented points
%
% EXAMPLE: This procedure is used in VLFLpprojectPL
%
exp_2012_10_27(nf,d)- Experiment for automatic connection of two solids
exp_2012_10_27(nf,d) % exp_2012_10_27(nf,d) - Experiment for automatic connection of two solids
% (by Tim Lueth, VLFL-Lib, 2012-OKT-27 as class: EXPERIMENTS)
%
% This experiment shows how to automatically connecting two solids by a
% bar. The STL of the bar and the STL of the two linked solids are
% written as file on disk.
%
% [VL,FL]=exp_2012_10_27([nf,d])
% === INPUT PARAMETERS ===
% nf: number of facets of the connector, default is automatic
% d: diameter/radius of the connector, defautl is 4
% === OUTPUT RESULTS ======
% VL: Vertex list of the wall
% FL: Facet list of the wall
%
% EXAMPLE: Simply type exp_2012_10_27
%
VLFLpprojectPL(PL,ez,VL,FL)- returns the surface of a parallel projection of a contour
VLFLpprojectPL(PL,ez,VL,FL) % VLFLpprojectPL(PL,ez,VL,FL) - returns the surface of a parallel projection of a contour
% (by Tim Lueth, VLFL-Lib, 2012-OKT-27 as class: SYNTHESIZING PROCEDURES)
%
% This fnctns was originally created to create "adaptors" between a tube
% and a solid. (Status of: 2017-04-01)
%
% See also: VLFLpprojectPLEL, VLprojection
%
% [VL,FL]=VLFLpprojectPL(PL,ez,VL,FL)
% === INPUT PARAMETERS ===
% PL: Point list to describe a contour
% ez: direction of the parallel projection
% VL: Vertex list of a solid
% FL: Facet list of a solid
% === OUTPUT RESULTS ======
% VL: Vertex list of the surface (PLE; PL)
% FL: Facet list of the surface
%
exp_2012_10_26- Experiment how to use a slicer and to generate a sliced volume
exp_2012_10_26 % exp_2012_10_26 - Experiment how to use a slicer and to generate a
% sliced volume
% (by Tim Lueth, VLFL-Lib, 2012-OKT-26 as class: EXPERIMENTS)
%
% exp_2012_10_26
%
% EXAMPLE: exp_2012_10_26
%
crosspointVLFL(VL,FL,p,ez)- returns the surfacepoint of a solid hit by a beam
crosspointVLFL(VL,FL,p,ez) % crosspointVLFL(VL,FL,p,ez) - returns the surfacepoint of a solid hit by a beam
% (by Tim Lueth, VLFL-Lib, 2012-OKT-26 as class: AUXILIARY PROCEDURES)
%
% Straight forward but fast procedure to calucate the surface point of a
% beam starting at point p in the direction of ez. (Status of: 2017-04-01)
%
% See also: intersectstriangle, VLprojection
%
% [cp,t,fi,a]=crosspointVLFL(VL,FL,p,ez)
% === INPUT PARAMETERS ===
% VL: Vertex list of a solid
% FL: Facet list of a solid
% p: beam starting point
% ez: beam direction vector
% === OUTPUT RESULTS ======
% cp: cross point on surface, empty if there is no crossing point
% t: distance (t * ez)
% fi: facet index of 1st crossed surface
% a: full list of facet index and distance [fi, d]
%
% EXAMPLE:
% SG=SGtransP(SGbox([80,80,5]),[0 0 40]); p=[0 0 0];
% crosspointVLFL(SG.VL,SG.FL,p,[0.2 0.1 1])
%
exp_2012_10_26_2(nf)- EXPERIMENT to generate a surface between a contour and a solid
exp_2012_10_26_2(nf) % exp_2012_10_26_2(nf) - EXPERIMENT to generate a surface between a
% contour and a solid
% (by Tim Lueth, VLFL-Lib, 2012-OKT-26 as class: EXPERIMENTS)
%
% Basic experimental version of the better and later exp_2012_10_27.
% Later used to generate procedure PLsupplement and VLFLpprojectPL
%
%
% PLE=exp_2012_10_26_2([nf])
% === INPUT PARAMETERS ===
% nf: number of facets
% === OUTPUT RESULTS ======
% PLE: Projected contour als vertex list
%
FTjacoringOL- returns the outer large ring STL-geometry of a JACO robot
FTjacoringOL % FTjacoringOL - returns the outer large ring STL-geometry of a JACO robot
% (by Tim Lueth, VLFL-Lib, 2012-OKT-26 as class: SYNTHESIZING PROCEDURES)
%
% See also: FTelement, FTclutch, FTjacoringIL, FTgearcase, FTcontour,
% FTgearframe
%
% FT=FTjacoringOL
% === OUTPUT RESULTS ======
% FT: Solid object's Vertex list and Facet list
%
% EXAMPLE: Show the Geometry
% A=FTjacoringOL; plotFT(A); snapplot;
%
FTjacoringIL- returns the inner large ring STL-geometry of a JACO robot
FTjacoringIL % FTjacoringIL - returns the inner large ring STL-geometry of a JACO robot
% (by Tim Lueth, VLFL-Lib, 2012-OKT-26 as class: SYNTHESIZING PROCEDURES)
%
% See also: FTelement, FTclutch, FTjacoringOL, FTgearcase, FTcontour,
% FTgearframe
%
% FT=FTjacoringIL
% === OUTPUT RESULTS ======
% FT: Solid object's Vertex list and Facet list
%
% EXAMPLE: Show the Geometry
% A=FTjacoringIL; plotFT(A); snapplot;
%
PLevolvente(r,w,n)- returns the point list of an evolvente curve
PLevolvente(r,w,n) % PLevolvente(r,w,n) - returns the point list of an evolvente curve
% (by Tim Lueth, VLFL-Lib, 2012-OKT-23 as class: ANALYTICAL GEOMETRY)
%
% The evolvent fnctn computes for a cord winded on a circumcircle, the
% position of the cord end after rewinding it a specified angle. When
% rewinded, the cord consists of part that is still winded on the
% circumcircle and a tangent part that is straight from the circumcircle.
% This fnctn is used to calculate gears. (Status of: 2017-01-05)
%
% See also: PLcircle, PLcircseg, PLgear, PLhelix, PLkidney, PLrand,
% PLspiral, PLsquare, PLstar
%
% PL=PLevolvente(r,[w,n])
% === INPUT PARAMETERS ===
% r: radius
% w: maximal angle; default is 2*pi
% n: length of PL; default is 12;
% === OUTPUT RESULTS ======
% PL: Point list (2D) of the evolvente/involute fnctn
%
% EXAMPLE: Show a typical evolute gear tooth flank (typical 20 degrees)
% PL=PLevolvente (10,pi/180*20,100);
% pplot (PL);
% axis equal; view (0,90)
%
exp_2012_10_23- EXPERIMENT returning the contour of an involute gear
exp_2012_10_23 % exp_2012_10_23 - EXPERIMENT returning the contour of an involute gear
% (by Tim Lueth, VLFL-Lib, 2012-OKT-23 as class: EXPERIMENTS)
%
% Work in progress
%
% exp_2012_10_23
%
ELswap(EL)- flips orientation of edge list
ELswap(EL) % ELswap(EL) - flips orientation of edge list
% (by Tim Lueth, VLFL-Lib, 2012-OKT-20 as class: AUXILIARY PROCEDURES)
%
% Does not support contour edge lists.
% EL=flipud(EL(:,[2 1]));
% (Status of: 2017-03-20)
%
% See also: FLswap, ELflip
%
% EL=ELswap(EL)
% === INPUT PARAMETERS ===
% EL: Edge list
% === OUTPUT RESULTS ======
% EL: Edge list flipped
%
% EXAMPLE: [EL ELswap(EL)]
%
FTclutch- returns a clutch for Fischertechnik Gear Motor
FTclutch % FTclutch - returns a clutch for Fischertechnik Gear Motor
% (by Tim Lueth, VLFL-Lib, 2012-OKT-20 as class: SYNTHESIZING PROCEDURES)
%
% See also: FTelement, FTjacoringOL, FTjacoringIL, FTgearcase, FTcontour,
% FTgearframe
%
% O=FTclutch
% === OUTPUT RESULTS ======
% O: Solid structure containing vertex list and facet list
%
% EXAMPLE: Generates and plots a gear box clutch for Fischertechnik
% O=FTclutch;
% plotFT(O);
%
PLcircle(R,nf,dw,Ry,ow)- returns a 2D point list of a circle or circle segment
PLcircle(R,nf,dw,Ry,ow) % PLcircle(R,nf,dw,Ry,ow) - returns a 2D point list of a circle or circle segment
% (by Tim Lueth, VLFL-Lib, 2012-OKT-19 as class: AUXILIARY PROCEDURES)
%
% PL circle starts not(!) at (R,0), but the first edge is going in
% y-direction. This has been done to simply generate squares or
% 2*n-Polygons. By using the offset angle, it is possible (Status of:
% 2017-02-05)
%
% See also: PLcircle, PLcircseg, PLevolvente, PLgearDIN, PLhelix,
% PLkidney, PLrand, PLspiral, PLsquare, PLstar, PLcircleoval
%
% PL=PLcircle(R,[nf,dw,Ry,ow])
% === INPUT PARAMETERS ===
% R: Radius
% nf: number of facets (default is nofrd (R,0.05))
% dw: circle segment ](0..2(pi] (default is 2*pi)
% Ry: Radius if ellipse (default is R)
% ow: Offset angle
% === OUTPUT RESULTS ======
% PL: Point / Vertex list
%
FTgearcase- returns a gearcase for the Fischertechnik gear motors
FTgearcase % FTgearcase - returns a gearcase for the Fischertechnik gear motors
% (by Tim Lueth, VLFL-Lib, 2012-OKT-19 as class: SYNTHESIZING PROCEDURES)
%
% See also: FTelement, FTclutch, FTjacoringOL, FTjacoringIL, FTcontour,
% FTgearframe
%
% FT=FTgearcase
% === OUTPUT RESULTS ======
% FT: Solid structure containing vertex list and facet list
%
% EXAMPLE: Generate a gear case:
% A=FTgearcase; plotFT(A); writestlFT (A);
%
FTelement(h,dtail)- generates kit elements similar to Fischertechnik
FTelement(h,dtail) % FTelement(h,dtail) - generates kit elements similar to Fischertechnik
% (by Tim Lueth, VLFL-Lib, 2012-OKT-14 as class: SYNTHESIZING PROCEDURES)
%
% Research procedure to generate parameterized Fischertechnik elements.
% (Status of: 2016-12-28)
%
% See also: FTclutch, FTjacoringOL, FTjacoringIL, FTgearcase, FTcontour,
% FTgearframe
%
% FT=FTelement([h,dtail])
% === INPUT PARAMETERS ===
% h: height of element; default is 30mm
% dtail: double dove tail (default is 0)
% === OUTPUT RESULTS ======
% FT: Solid structure containing vertex list and facet list
%
% EXAMPLE: Generate an element:
% A=FTelement; plotFT(A); writestlFT (A);
%
exp_2012_08_13 (tcase,tface)- returns surfaces of solid A after cutting solid B
exp_2012_08_13 (tcase,tface) % exp_2012_08_13 (tcase,tface) - returns surfaces of solid A after
% cutting solid B
% (by Tim Lueth, VLFL-Lib, 2012-AUG-13 as class: EXPERIMENTS)
%
% Mainly for testing VLFLseparateEL (Successfully)
% Experimenal breaktrough on Aug-9 morning. Uses VLFLtestsolids.
% A JPG-Snapshot is saved, if a second input parameter is used.
%
% exp_2012_08_13([tcase,tface])
% === INPUT PARAMETERS ===
% tcase: 'A1', 'A2', usw. as Testsolids
% tface: Facet of interest; default=0; (all)
%
% EXAMPLE: Simple test
% exp_2012_08_13 ('A5',1);
%
exp_2012_08_10 (tcase)- returns surfaces of solid A after cutting solid B
exp_2012_08_10 (tcase) % exp_2012_08_10 (tcase) - returns surfaces of solid A after cutting
% solid B
% (by Tim Lueth, VLFL-Lib, 2012-AUG-09 as class: EXPERIMENTS)
%
% Mainly for testing VLFLseparateEL (Successfully)
% Experimenal breaktrough on Aug-9 morning. Uses VLFLtestsolids.
% A JPG-Snapshot is saved, if a second input parameter is used.
%
% exp_2012_08_10([tcase])
% === INPUT PARAMETERS ===
% tcase: 'A1', 'A2', usw. as Testsolids
%
% EXAMPLE: Simple test
% exp_2012_08_10 ('A5','snap');
%
exp_2012_08_09 (tcase)- returns the reconstructed facets of A after trying A-B
exp_2012_08_09 (tcase) % exp_2012_08_09 (tcase) - returns the reconstructed facets of A after
% trying A-B
% (by Tim Lueth, VLFL-Lib, 2012-AUG-09 as class: EXPERIMENTS)
%
% Experimental procedure
%
% exp_2012_08_09([tcase])
% === INPUT PARAMETERS ===
% tcase: Parameter for VLFLtestsolids
%
% EXAMPLE: Try A1, A2, A3, A4, A5
% exp_2012_080_09 ('A1')
%
exp_2012_08_08 (tcase)- plots the crossing lines of two solids
exp_2012_08_08 (tcase) % exp_2012_08_08 (tcase) - plots the crossing lines of two solids
% (by Tim Lueth, VLFL-Lib, 2012-AUG-09 as class: EXPERIMENTS)
%
% uses VLFLtestsolids as input parameter for showing different test
% cases. Uses:
% crossingfacets2VLFL
% VLFLcrossF
%
% exp_2012_08_08([tcase])
% === INPUT PARAMETERS ===
% tcase:
%
% EXAMPLE: Show two separated blocks crossing one facet
% exp_2012_08_08 ('A8')
%
exp_2012_08_07(tcase)- Experiment draws the cutting points on A of substraction: A-B
exp_2012_08_07(tcase) % exp_2012_08_07(tcase) - Experiment draws the cutting points on A of
% substraction: A-B
% (by Tim Lueth, VLFL-Lib, 2012-AUG-07 as class: EXPERIMENTS)
%
% [VLB,FLB,p1,p2,p3]=exp_2012_08_07([tcase])
% === INPUT PARAMETERS ===
% tcase: Parameter for VLFLtestsolids
% === OUTPUT RESULTS ======
% VLB: Vertex list of cutting body
% FLB: Facet list of cutting body, negative facets
% p1: p1 of last cutted facet of solid A
% p2: p2 of last cutted facet of solid A
% p3: p3 of last cutted facet of solid A
%
snapplot (pname)- saves the current figure as JPG-File on the user desktop
snapplot (pname) % snapplot (pname) - saves the current figure as JPG-File on the user desktop
% (by Tim Lueth, VLFL-Lib, 2012-AUG-04 as class: VISUALIZATION)
%
% See also: PRplot, copyplot
%
% snapplot([pname])
% === INPUT PARAMETERS ===
% pname: name of shown procedure, default is 'Tim C. Lueth'
%
% EXAMPLE: Call it after plotting in a figure
% VLFLplot (VL,FL);
% snapplot (exp_2012_08_04)
%
VLFLofgca- returns the vertex list and facet list of the current figure
VLFLofgca % VLFLofgca - returns the vertex list and facet list of the current figure
% (by Tim Lueth, VLFL-Lib, 2012-AUG-04 as class: VISUALIZATION)
%
% This procedure can be used to write STL file of the current figure, or
% to print the edges of the edge list (Status of: 2013-08-04)
%
% [VL,FL,FEL]=VLFLofgca
% === OUTPUT RESULTS ======
% VL: Vertex list of the patches/facets of the current figure
% FL: Facet list of the patches/facets of the current figure
% FEL: Feature edge list for pi/6
%
% EXAMPLE: save the current figure as STL-File
% [VL,FL,FEL]=VLFLofgca;
% VLFLwriteSTL(VL,FL);
% VLELplots (VL,FEL,'k',1)
%
exp_2012_08_04- experimental procedure to test Subtractiion of two solids
exp_2012_08_04 % exp_2012_08_04 - experimental procedure to test Subtractiion of two
% solids
% (by Tim Lueth, VLFL-Lib, 2012-AUG-04 as class: SYNTHESIZING PROCEDURES)
%
% [VLB,FLB,p1,p2,p3]=exp_2012_08_04
% === OUTPUT RESULTS ======
% VLB: Vertex list of substracted body
% FLB: Facet list of substracted body
% p1: p1 of current triangle
% p2: p2 of current triangle
% p3: p3 of current triangle
%
zoompatch(VL,fac,md)- zooms to see all patches of the current figure axis
zoompatch(VL,fac,md) % zoompatch(VL,fac,md) - zooms to see all patches of the current figure
% axis
% (by Tim Lueth, VLFL-Lib, 2012-AUG-01 as class: VISUALIZATION)
%
% adjusts the axis so that only the visible parts are shown.
% with any parameter the points of facets of gcf is used.
% It is also possible to declare a vertex list, or a solid (Status of:
% 2015-08-09)
%
% zoompatch([VL,fac,md])
% === INPUT PARAMETERS ===
% VL: Vertex list or Solid Geometry to zoom on; default is gca
% fac: surrounding area; default is 0.5, relative to Bounding Box
% md: minimal distance; default is 1; distance in mm
%
exp_2012_07_30 (tcase)- Experiment for testing VLFLcutter and VLFLcutter3P
exp_2012_07_30 (tcase) % exp_2012_07_30 (tcase) - Experiment for testing VLFLcutter and
% VLFLcutter3P
% (by Tim Lueth, VLFL-Lib, 2012-JUL-30 as class: EXPERIMENTS)
%
% exp_2012_07_30([tcase])
% === INPUT PARAMETERS ===
% tcase: string for VLFLtestsolids; default is 'D1'
%
% EXAMPLE: exp_2012_07_30 ('D1');
%
ELofFL(FL)- converts a facet list into an edge list (simple)
ELofFL(FL) % ELofFL(FL) - converts a facet list into an edge list (simple)
% (by Tim Lueth, VLFL-Lib, 2012-JUL-29 as class: AUXILIARY PROCEDURES)
%
% EL=ELofFL(FL)
% === INPUT PARAMETERS ===
% FL: Facet list (n x 3)
% === OUTPUT RESULTS ======
% EL: Edge list (n x 2)
%
% EXAMPLE: Show the edges of a VLFL-solid
% [VL,FL]=VLFLbox (10,20,30);
% EL=ELofFL (VL);
% VLELplot (VL,EL);
%
textVL (VL,c,s,nt,lb)- plots descriptors for each facet in the figure using the text command
textVL (VL,c,s,nt,lb) % textVL (VL,c,s,nt,lb) - plots descriptors for each facet in the figure using the text command
% (by Tim Lueth, VLFL-Lib, 2012-JUL-29 as class: VISUALIZATION)
%
% plots either point descriptors into the figure of all point in VL or
% selects justs the numbers given in list nt. 99 points are the maximum
% number of points that will be plottet.
% If the length(lb) == number of points, the points are marked by the
% letters lb(i). (Status of: 2017-06-05)
%
% See also: textT, textP, textCVL
%
% textVL(VL,[c,s,nt,lb])
% === INPUT PARAMETERS ===
% VL: Vertex list
% c: Color, default is black
% s: Size, default is 10
% nt: optional list of selected points
% lb: optional string for text; default is 'P'
%
% EXAMPLE: Different examples for plotting
% SGsample(4); a=SGsample(4); textVL(a.VL,[],12,[23 24 55 56]); view
% (-130,30)
% SG=SGbox([60,40,20]); SGfigure(SG); view(-30,30); textVL(SG.VL,[],16)
% SG=SGbox([60,40,20]); SGfigure(SG); view(-30,30);
% textVL(SG.VL,[],16,[],'A')
% SG=SGbox([60,40,20]); SGfigure(SG); view(-30,30);
% textVL(SG.VL,[],16,[],'ABCDEFGH')
%
VLui(m,res,ax)- returns a vertex list drawn by the user in a plot window
VLui(m,res,ax) % VLui(m,res,ax) - returns a vertex list drawn by the user in a plot
% window
% (by Tim Lueth, VLFL-Lib, 2012-JUL-25 as class: AUXILIARY PROCEDURES)
%
% New points are set in red. Finally all are rounded to the given
% resolution and plotted in blue. (Status of: 2013-09-20)
%
% PL=VLui([m,res,ax])
% === INPUT PARAMETERS ===
% m: number of points; default = inf
% res: resolution; default = 0.1
% ax: axis [xmin xmax ymin ymax]; default=[-10 110 -10 110]
% === OUTPUT RESULTS ======
% PL: Vertex list (z=0);
%
% EXAMPLE: Different examples to test DelaunayTri;
% PL=VLui, dt=DelaunayTri(PL(:,1), PL(:,2)), triplot (dt), show
% for i=1:size(PL,1); text (PL(i,1), PL(i,2), PL(i,3),sprintf('P%i',i));
% end;
% k=convexHull(dt), pplot (PL(k,:)')
%
intersectmatrix(p1,p2,p3,VL,FL)- returns an intersection matrix between a triangle facet and a VLFL-solid
intersectmatrix(p1,p2,p3,VL,FL) % intersectmatrix(p1,p2,p3,VL,FL) - returns an intersection matrix
% between a triangle facet and a VLFL-solid
% (by Tim Lueth, VLFL-Lib, 2012-JUL-17 as class: ANALYZING PROCEDURES)
%
% This procedure uses cross2F to calculate of intersection points of a
% triangle with a full VLFL-solid.
% This procedure needs some improvement for becoming faster.
% The matrix format is described in cross2F
%
% TL=intersectmatrix(p1,p2,p3,VL,FL)
% === INPUT PARAMETERS ===
% p1: Point 1 of triangle
% p2: Point 2 of triangle
% p3: Point 3 of triangle
% VL: Vertex list
% FL: Facet list
% === OUTPUT RESULTS ======
% TL: intersection Matrix
%
VMplot_2012 (IM,p,SG)- plots a 3D volumetric matrix in 2x2 view
VMplot_2012 (IM,p,SG) % VMplot_2012 (IM,p,SG) - plots a 3D volumetric matrix in 2x2 view
% (by Tim Lueth, NAV-Lib, 2012-JUL-16 as class: VISUALIZATION)
%
% Name changed into VMplot_2012 (Status of: 2017-02-22)
%
% See also: VM, VMimage, VMimrot90, VMmontage, VMplot, VMpseudo3D,
% VMreaddicom, VMreaddicomdir, VMuidicom
%
% VMplot_2012(IM,[p,SG])
% === INPUT PARAMETERS ===
% IM: 3D Matrix
% p: optional point of interest; default is center
% SG: optional solid of the Volume;
%
% EXAMPLE:
% [V,vs]=VMreaddicomdir('/Volumes/LUETH-WIN/WIN AIM Matlab
% Libraries/VLFL-Lib/AIM_DICOMFILES');
% [V,vs]=VMresize(V,vs,vs);
% SG=SGofVMdelaunay(V>1400,vs);
% VMplot(V,'',SG)
%
FLofTetrahedron(FL4,allf)- returns the triangles of a tetrahedron list
FLofTetrahedron(FL4,allf) % FLofTetrahedron(FL4,allf) - returns the triangles of a tetrahedron list
% (by Tim Lueth, VLFL-Lib, 2012-JUL-15 as class: AUXILIARY PROCEDURES)
%
% DelaunayTri uses tetrahedrons as internal representation instead of
% triangles. To get the outer triangle facets of a tetrahedron you can
% also use: [FL,VL]=freeBoundary(DelaunayTri(VL(:,1),VL(:,2),VL(:,3)));
% (Status of: 2014-12-26)
%
% [FL,FLA]=FLofTetrahedron(FL4,[allf])
% === INPUT PARAMETERS ===
% FL4: Tetrahedron list from DelaunayTri
% allf: true = all facets, false = outside facets
% === OUTPUT RESULTS ======
% FL: Outer facet list
% FLA: All facets of the tetrahedrons
%
% EXAMPLE: Show the tetrahedrons of a cube generated by vertices and
% Delaunaytri
% [VL,FL]=VLFLbox(10,10,10);
% dt=DelaunayTri(VL(:,1), VL(:,2), VL(:,3))
% [FL,FLA]=FLofTetrahedron(dt.Triangulation);
% app_2012_11_09 (VL,FLA)
%
isodd(x)- returns whether a numer is even or odd
isodd(x) % isodd(x) - returns whether a numer is even or odd
% (by Tim Lueth, VLFL-Lib, 2012-JUL-15 as class: AUXILIARY PROCEDURES)
%
% r=(mod(x,2)~=0) (Status of: 2017-04-24)
%
% r=isodd(x)
% === INPUT PARAMETERS ===
% x: number
% === OUTPUT RESULTS ======
% r:
%
exp_2012_07_13(h)- EXPERIMENT, unfinished for use of crossedgeVLFL
exp_2012_07_13(h) % exp_2012_07_13(h) - EXPERIMENT, unfinished for use of crossedgeVLFL
% (by Tim Lueth, VLFL-Lib, 2013-AUG-15 as class: UNCLEAR STATUS)
%
% [VL,FL,XVL,XFL,h]=exp_2012_07_13([h])
% === INPUT PARAMETERS ===
% h: handle of a figure
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet List
% XVL:
% XFL:
% h:
%
intersectstriangle(p,d,v0,v1,v2)- returns whether a intersection between a ray and a triangle existst
intersectstriangle(p,d,v0,v1,v2) % intersectstriangle(p,d,v0,v1,v2) - returns whether a intersection between a ray and a triangle existst
% (by Tim Lueth, VLFL-Lib, 2012-JUL-13 as class: ANALYTICAL GEOMETRY)
%
% References see: http://www.lighthouse3d.com/tutorials/maths (Status of:
% 2017-04-01)
%
% See also: crosspointVLFL, VLprojection
%
% [b,t]=intersectstriangle(p,d,v0,v1,v2)
% === INPUT PARAMETERS ===
% p: Point of line
% d: Direction of line
% v0: Vertex 0
% v1: Vertex 1
% v2: Vertex 2
% === OUTPUT RESULTS ======
% b: if t>0 and intersecting point exists
% t: intersecting point is p+t*d
%
% EXAMPLE:
% [a,b]=intersectstriangle([5 5 -10],[0 0 1],[0 0 0],[10 0 0],[10 10 0])
%
roundn(x,lim)- rounds a vector or matrix to a defined number of digits
roundn(x,lim) % roundn(x,lim) - rounds a vector or matrix to a defined number of digits
% (by Tim Lueth, VLFL-Lib, 2012-JUL-10 as class: AUXILIARY PROCEDURES)
%
% It is extremely fast procedure! (Status of: 2013-08-15)
%
% x=roundn(x,lim)
% === INPUT PARAMETERS ===
% x: Number, Vector, Matrix
% lim: Limit
% === OUTPUT RESULTS ======
% x: result
%
% EXAMPLE: Round to 2 Digits:
% roundn (rand(10),0.01)
%
show- simply brings the current figure in the front
show % show - simply brings the current figure in the front
% (by Tim Lueth, VLFL-Lib, 2012-JUL-08 as class: VISUALIZATION)
%
% show == set (gcf,'visible','on') (Status of: 2014-12-26)
%
% See also: smbDrawNow, drawnow
%
% show
%
exp_2012_07_06- Example for the use of the RP-Lib
exp_2012_07_06 % exp_2012_07_06 - Example for the use of the RP-Lib
% (by Tim Lueth, RP-Lib, 2012-JUL-06 as class: EXPERIMENTS)
%
% O=exp_2012_07_06
% === OUTPUT RESULTS ======
% O:
%
% EXAMPLE: Test some features of the RP-Lib
% O=exp_2012_07_06
%
VMreaddicom(pathname,filename)- reads an image (nxn) or image stack (nxnxm) from a dicom directory
VMreaddicom(pathname,filename) % VMreaddicom(pathname,filename) - reads an image (nxn) or image stack (nxnxm) from a dicom directory
% (by Tim Lueth, VLFL-Lib, 2012-JUN-15 as class: VOXELS)
%
% If no pathname or file name is given, uigetfile is used to select it by
% a dialog window.
% For full information on the dicom format read:
% http://medical.nema.org/Dicom/2011/11_03pu.pdf (Status of: 2017-02-16)
%
% See also: VM, VMimage, VMimrot90, VMmontage, VMplot, VMpseudo3D,
% VMreaddicomdir, VMuidicom
%
% IM=VMreaddicom([pathname,filename])
% === INPUT PARAMETERS ===
% pathname: optional pathname
% filename: optional pathname
% === OUTPUT RESULTS ======
% IM: voxel volume model (VM)
%
% EXAMPLE: I=VMreaddicom('/Volumes/PLATTE LUETH ALL/Pictures/ Pictures
% Camera/Camera 2006/06-10-16 DICOM HNO ENT/dicom');
%
VLFLui(mag,c)- Opens a dialog, reads and plots an STL-File
VLFLui(mag,c) % VLFLui(mag,c) - Opens a dialog, reads and plots an STL-File
% (by Tim Lueth, VLFL-Lib, 2012-JUN-11 as class: USER INTERFACE)
%
% [VL,FL,filename,pathname]=VLFLui([mag,c])
% === INPUT PARAMETERS ===
% mag: magnification; default is 1
% c: Color of Object, Plots only if color is defined
% === OUTPUT RESULTS ======
% VL: Vertex List of STL File
% FL: Facet List of STL File
% filename: filename of selected file
% pathname: pathname of selected file
%
% EXAMPLE: Read in a STL File
% [VL,FL]=VLFLui
%
exp_2012_06_10;- Experiment that show a simple user interace
exp_2012_06_10; % exp_2012_06_10; - Experiment that show a simple user interace
% (by Tim Lueth, VLFL-Lib, 2012-JUN-09 as class: EXPERIMENTS)
%
% exp_2012_06_10;
%
% EXAMPLE: Opens a dialog window and displays a STL File
%
exp_2012_06_09 (FNAME)- Experiment to display an object in 8 different colors
exp_2012_06_09 (FNAME) % exp_2012_06_09 (FNAME) - Experiment to display an object in 8 different
% colors
% (by Tim Lueth, VLFL-Lib, 2012-JUN-09 as class: EXPERIMENTS)
%
% exp_2012_06_09([FNAME])
% === INPUT PARAMETERS ===
% FNAME: File name
%
% EXAMPLE: Simple 3D Editor for reading and viewing STL file
% 'TESTFILE.STL'
% exp_2012_06_08 ('TESTFILE')
%
exp_2012_06_08 (FNAME)- Experiment to show how to show an STL on screen and how to select facets and vertices
exp_2012_06_08 (FNAME) % exp_2012_06_08 (FNAME) - Experiment to show how to show an STL on
% screen and how to select facets and vertices
% (by Tim Lueth, VLFL-Lib, 2012-JUN-08 as class: EXPERIMENTS)
%
% exp_2012_06_08([FNAME])
% === INPUT PARAMETERS ===
% FNAME: File name
%
% EXAMPLE: Simple 3D Editor for reading and viewing STL file
% 'TESTFILE.STL'
% exp_2012_06_08 ('TESTFILE')
%
VLFLplots(VL,FL,c,fe)- plots an object/solid as shaded or faceted object
VLFLplots(VL,FL,c,fe) % VLFLplots(VL,FL,c,fe) - plots an object/solid as shaded or faceted
% object
% (by Tim Lueth, VLFL-Lib, 2012-JUN-08 as class: VISUALIZATION)
%
% much faster than VLFLplot. Works with select3d
% This procedure supports also facets list of type cell: {FL1,FL2,FL3}.
% It also supports facets list separated by NaN: [FL1;NaN NaN NaN;FL2]
% (Status of: 2015-07-31)
%
% X=VLFLplots(VL,FL,[c,fe])
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% c: Color; default is 'r'
% fe: feature edge list
% === OUTPUT RESULTS ======
% X: handle to trisurf
%
% EXAMPLE: Plot a shaded solid in magenta:
% VLFLplots (VL,FL,'m');
% VLFLplotlight;
%
VLFLplots4 (VL,FL,c)- plots an object/solid as shaded or faceted object in 4 views
VLFLplots4 (VL,FL,c) % VLFLplots4 (VL,FL,c) - plots an object/solid as shaded or faceted
% object in 4 views
% (by Tim Lueth, VLFL-Lib, 2012-JUN-08 as class: VISUALIZATION)
%
% much faster than VLFLplot4. Works with select3d
%
% VLFLplots4(VL,FL,[c])
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% c: Color
%
% EXAMPLE: Plot a shaded solid in 4 views in red:
% VLFLplots (VL,FL,'r');
% VLFLplotlight;
%
VLFLplotlight (mode,al,goh,c)- switches the light and renderer on for VLFLplots and VLFLplots4
VLFLplotlight (mode,al,goh,c) % VLFLplotlight (mode,al,goh,c) - switches the light and renderer on for VLFLplots and VLFLplots4
% (by Tim Lueth, VLFL-Lib, 2012-JUN-08 as class: VISUALIZATION)
%
% VLFLplotlight support lighting and transparency
% mode=0; Faceted and flat
% mode=1; shaded and interpolated (Status of: 2017-03-19)
%
% See also: VLFLplot, VLFLplot, VLFLplots4, VLFLcamlight
%
% VLFLplotlight([mode,al,goh,c])
% === INPUT PARAMETERS ===
% mode: Rendering mode;
% al: Transpanencecy
% goh: graphic object handle; default is gcf
% c: color of the object only it is a patch
%
% EXAMPLE: VLFLplotlight (0,0); % Mesh
% VLFLplotlight (0,1); % Facets =VLFLplotlight (0);
% VLFLplotlight (1,1); % Rendered =VLFLplotlight (1);
% VLFLplotlight (1,0.5); % Transparancy
% VLFLplotlight (1,0); % Invisible
% ginput (1); VLFLplotlight (0,1,gco); % Current patch as facets
% ginput (1); VLFLplotlight (1,1,gco); % Current patch as shaded
% ginput (1); VLFLplotlight (1,0.9,gco,'r'); % Current patch as
% transparent red
%
exp_2012_06_07 (FNAME)- Experiment to show how to show an STL on screen and how to select facets and vertices in 3D
exp_2012_06_07 (FNAME) % exp_2012_06_07 (FNAME) - Experiment to show how to show an STL on
% screen and how to select facets and vertices in 3D
% (by Tim Lueth, VLFL-Lib, 2012-JUN-07 as class: EXPERIMENTS)
%
% Uses Matlab-Central procedure select3D or ginput3
%
% exp_2012_06_07([FNAME])
% === INPUT PARAMETERS ===
% FNAME: File name
%
% EXAMPLE: Simple 3D Editor for reading and viewing STL file
% 'TESTFILE.STL'
% exp_2012_06_07 ('TESTFILE')
%
select3d(obj)- Determines the selected point in 3-D data space.
select3d(obj) % select3d(obj) - Determines the selected point in 3-D data space.
% (by MATLAB-CENTRAL, VLFL-Lib, 2012-JUN-06 as class: VISUALIZATION)
%
% See also: selectV3d, vertexpicker, getpixelposition, pixelofaxis
%
% [pout,vout,viout,facevout,faceiout]=select3d(obj)
% === INPUT PARAMETERS ===
% obj: Graphics Object: default is gco
% === OUTPUT RESULTS ======
% pout: point
% vout: next vertex
% viout: vertex list index
% facevout: touched facet
% faceiout: facet list index
%
% EXAMPLE: [VL,FL]=VLFLreadstl ('Filename');
% VLFLplot (VL,FL,'r');
% ginput(1);
% [p,v,vi,f,fi]=select3D;pplot([p],'r.',1); pplot ([v],'b*',2); pplot
% (VL([FL(fi,:) FL(fi,1)],:)','m-');
%
%
VLBeziernoose(d,h,b,a,n)- returns a Point list of a noose as link between 2 points with a desired spring length
VLBeziernoose(d,h,b,a,n) % VLBeziernoose(d,h,b,a,n) - returns a Point list of a noose as link
% between 2 points with a desired spring length
% (by Tim Lueth, VLFL-Lib, 2012-MAI-20 as class: SYNTHESIZING PROCEDURES)
%
% The procedure uses the concept of: Gunter Erhard (2008): "Konstruieren
% mit Kunststoffen [Design for Polymers]", Hanser Verlag, Muenchen, 4.
% Auflage, p. (Status of: 2012-05-22)
%
% VL=VLBeziernoose(d,h,b,a,n)
% === INPUT PARAMETERS ===
% d: length in x
% h: half of the height in y
% b: upper neck of the noose
% a: lower neck of the noose
% n: number of points
% === OUTPUT RESULTS ======
% VL: Point list as vertex list
%
% EXAMPLE: Create a Noose:
% [VL,PL]=VLBeziernoose (60,10,5,5,100);VLFLfigure; VLplot(VL), VLplot
% (PL)
% [NVL,NFL]=VLFLexpandPL (VL',2,3); NVL=VLswapYZ(NVL); VLFLplot (NVL,NFL)
%
exp_2012_05_18- this experiments writes a STL object of a Bezier curve for connecting two chain links
exp_2012_05_18 % exp_2012_05_18 - this experiments writes a STL object of a Bezier curve
% for connecting two chain links
% (by Tim Lueth, VLFL-Lib, 2012-MAI-18 as class: EXPERIMENTS)
%
% [VL,FL]=exp_2012_05_18
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
VLBezierC(p,k)- returns a Bezier curve for a given list of points
VLBezierC(p,k) % VLBezierC(p,k) - returns a Bezier curve for a given list of points
% (by Tim Lueth, VLFL-Lib, 2012-MAI-17 as class: ANALYTICAL GEOMETRY)
%
% val=VLBezierC(p,k)
% === INPUT PARAMETERS ===
% p: Vertex list
% k: number of points of the Bezier curve
% === OUTPUT RESULTS ======
% val: Vertex list of the Bezier curve
%
% EXAMPLE: PL=[0 0 0; 5 0 0; 5 5 0; 0 10 0; 0 15 0; 15 15 10]
% VL=VLBezierC(PL,20); VLFLfigure; VLplot(VL), VLplot (PL)
%
VLunite2C(VL,PL,CCL,EPL);- returns for 2 contour lines from inside2C the united vertex list
VLunite2C(VL,PL,CCL,EPL); % VLunite2C(VL,PL,CCL,EPL); - returns for 2 contour lines from inside2C
% the united vertex list
% (by Tim Lueth, VLFL-Lib, 2012-MAI-12 as class: SYNTHESIZING PROCEDURES)
%
% powerful procedure
%
% UVL=VLunite2C(VL,PL,[CCL,EPL]);
% === INPUT PARAMETERS ===
% VL: Vertex contour list 1 as used in inside2C
% PL: Vertex contour list 1 as used in inside2C
% CCL: Crossed Countour list as generated by inside2C
% EPL: Edge processed list as generated by inside2C
% === OUTPUT RESULTS ======
% UVL: United vertex list
%
% EXAMPLE: Similar commands:
% VLunite2C
% VLintersect2C
% VLsub
%
exp_2012_05_11(dx,dy,f1,f2)- returns an STL file of two united contours
exp_2012_05_11(dx,dy,f1,f2) % exp_2012_05_11(dx,dy,f1,f2) - returns an STL file of two united contours
% (by Tim Lueth, VLFL-Lib, 2012-MAI-12 as class: EXPERIMENTS)
%
% [X,CCL,EPL]=exp_2012_05_11([dx,dy,f1,f2])
% === INPUT PARAMETERS ===
% dx: X displacement of polygon 1; default is 10
% dy: Y displacement of polygon 1; default is 10
% f1: Number of facts of polygon 1 ; default is 3
% f2: Number of facts of polygon 2; default is 3
% === OUTPUT RESULTS ======
% X:
% CCL:
% EPL:
%
VLFLcreatecross(X,Y,H,b)- returns a solid cross model in the x/y plane
VLFLcreatecross(X,Y,H,b) % VLFLcreatecross(X,Y,H,b) - returns a solid cross model in the x/y plane
% (by Tim Lueth, VLFL-Lib, 2012-MAI-05 as class: SYNTHESIZING PROCEDURES)
%
% This is a fully creator procedure to generates a 2.5D X-shaped
% structure of size X by Y with size H and bar width b
%
% [VL,FL,CL]=VLFLcreatecross(X,Y,H,b)
% === INPUT PARAMETERS ===
% X: Size in X [0..X]
% Y: Size in Y [0..Y]
% H: Size in Z [0..H]
% b: bar width
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% CL: Contour list
%
% EXAMPLE: Cross of size 40x60 with thickness 4 and bar width of 5 mm
% closeall; [VL,FL]=VLFLcreatecross (40,60,4,5); VLFLplot (VL,FL);
%
VLFLcreateframe(X,Y,H,b)- returns a solid frame model in the x/y plane
VLFLcreateframe(X,Y,H,b) % VLFLcreateframe(X,Y,H,b) - returns a solid frame model in the x/y plane
% (by Tim Lueth, VLFL-Lib, 2012-MAI-05 as class: SYNTHESIZING PROCEDURES)
%
% This is a fully creator procedure to generates a 2.5D frame shaped
% structure of size X by Y with size H and bar width b
%
% [VL,FL,CLO,CLI]=VLFLcreateframe(X,Y,H,b)
% === INPUT PARAMETERS ===
% X: Size in X [0..X]
% Y: Size in Y [0..Y]
% H: Size in Z [0..H]
% b: bar width
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% CLO: Contour list
% CLI:
%
% EXAMPLE: frame of size 40x60 with thickness 4 and bar width of 5 mm
% closeall; [VL,FL]=VLFLcreatecross (40,60,4,5); VLFLplot (VL,FL);
%
VLFLcreateblock(X,Y,H)- returns a solid block model in the x/y plane
VLFLcreateblock(X,Y,H) % VLFLcreateblock(X,Y,H) - returns a solid block model in the x/y plane
% (by Tim Lueth, VLFL-Lib, 2012-MAI-05 as class: SYNTHESIZING PROCEDURES)
%
% This is a fully creator procedure to generates a 2.5D solid block
% structure of size X by Y with size H
%
% [VL,FL,CL]=VLFLcreateblock(X,Y,H)
% === INPUT PARAMETERS ===
% X: Size in X [0..X]
% Y: Size in Y [0..Y]
% H: Size in Z [0..H]
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% CL: Contour list
%
% EXAMPLE: Block of size 40x60 with height of 70 mm
% closeall; [VL,FL]=VLFLcreateblock(40,60,70); VLFLplot (VL,FL);
%
VLFLcreateshaft(R,H);- returns a solid shaft model in the x/y plane
VLFLcreateshaft(R,H); % VLFLcreateshaft(R,H); - returns a solid shaft model in the x/y plane
% (by Tim Lueth, VLFL-Lib, 2012-MAI-05 as class: SYNTHESIZING PROCEDURES)
%
% This is a fully creator procedure to generates a 2.5D shaft structure
% of size X by Y with size H
%
% [VL,FL,CL,f]=VLFLcreateshaft(R,H);
% === INPUT PARAMETERS ===
% R: Radius
% H: Size in Z [0..H]
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% CL: Contour list
% f: number of facets
%
% EXAMPLE: Shaft of radius 10 with height of 60 mm
% closeall; [VL,FL]=VLFLcreateshaft (10,60); VLFLplot (VL,FL);
%
VLFLcreatesleeve(Ro,Ri,H);- returns a solid sleeve model in the x/y plane
VLFLcreatesleeve(Ro,Ri,H); % VLFLcreatesleeve(Ro,Ri,H); - returns a solid sleeve model in the x/y
% plane
% (by Tim Lueth, VLFL-Lib, 2012-MAI-05 as class: SYNTHESIZING PROCEDURES)
%
% This is a fully creator procedure to generates a 2.5D sleeve structure
% of size X by Y with size H
%
% [VL,FL,CLO,CLI,f]=VLFLcreatesleeve(Ro,Ri,H);
% === INPUT PARAMETERS ===
% Ro: Outer Radius
% Ri: Inner Radius
% H: Size in Z [0..H]
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% CLO: Outer contour list
% CLI: Inner contour list
% f: number of facets
%
% EXAMPLE: Shaft of radius 10 with height of 60 mm
% [VL,FL,CLO,CLI,f]=VLFLcreatesleeve (10,8,60);
% closeall; VLFLplot (VL,FL); f
%
VLFLcreateslottedsleeve(Ro,Ri,H,nr);- returns a solid slotted sleeve model in the x/y plane
VLFLcreateslottedsleeve(Ro,Ri,H,nr); % VLFLcreateslottedsleeve(Ro,Ri,H,nr); - returns a solid slotted sleeve
% model in the x/y plane
% (by Tim Lueth, VLFL-Lib, 2012-MAI-05 as class: SYNTHESIZING PROCEDURES)
%
% This is a fully creator procedure to generates a 2.5D slotted sleeve
% structure of size X by Y with size H
%
% [VL,FL,CLO,CLI,f]=VLFLcreateslottedsleeve(Ro,Ri,H,[nr]);
% === INPUT PARAMETERS ===
% Ro: Outer Radius
% Ri: Inner Radius
% H: Size in Z [0..H]
% nr: nr of slots; default is 3
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% CLO: Outer contour list
% CLI: Inner contour list
% f: number of facets
%
% EXAMPLE: Shaft of radius 10 with height of 60 mm
% [VL,FL,CLO,CLI,f]=VLFLcreateslottedsleeve (10,8,60);
% closeall; VLFLplot (VL,FL); f
%
TofVL(VL,ez,force)- returns the main axis of a vertex list or SG
TofVL(VL,ez,force) % TofVL(VL,ez,force) - returns the main axis of a vertex list or SG
% (by Tim Lueth, VLFL-Lib, 2012-MAI-03 as class: ANALYTICAL GEOMETRY)
%
% This procedure is similar to TPL but calculates the covariance matrix
% and the main axis and the Eigen values. The results are very similar
% but less heuristic.
% If 4 or more vertices are used, the convex hull is calculated first.
% if force is true; ez is forced as new ez vector; this allows to rotate
% in only two dimensions;
% if ez=[1 0 0] the fnctn fails, since ex is [1 0 0] by definition
% (Status of: 2017-01-21)
%
% See also: TofR, TPL, TofDPhiH, T3ofT2, T3P, T2P
%
% T=TofVL(VL,[ez,force])
% === INPUT PARAMETERS ===
% VL: Vertex list or Solid Geometry
% ez: ez vector for turning; default is empty
% force: if true ez is forced as ez vector; default is false
% === OUTPUT RESULTS ======
% T: HT Matrix of the main axis
%
% EXAMPLE:
% TofVL(rand(4,3)); % turns in all direction
% TofVL(rand(4,3)*100,[0 0 1]); % would only change something if
% ez=[0 0 -1]
% TofVL(rand(4,3)*100,[0 0 1],true); % turns only around ez;
%
exp_2012_05_03-
exp_2012_05_03 % exp_2012_05_03 -
% (by Tim Lueth, EXPERIMENT, 2012-MAI-03 as class: EXPERIMENTS)
%
% This procedures generates a simple body, generates a covering hull and
% separates the hull into several pieces
%
% exp_2012_05_03
%
exp_2012_05_02 (unionnr)- writes a STL file of an experimental basket with a date stamp on a defined union surface
exp_2012_05_02 (unionnr) % exp_2012_05_02 (unionnr) - writes a STL file of an experimental basket
% with a date stamp on a defined union surface
% (by Tim Lueth, VLFL-Lib, 2012-MAI-02 as class: EXPERIMENTS)
%
% exp_2012_05_02([unionnr])
% === INPUT PARAMETERS ===
% unionnr: Union nr to set the date stamp on
%
% EXAMPLE: set it in the middle of the basket
% exp_2012_05_02(2)
%
VLtrans0(VL)- moves an object into the origin of the coordinate system
VLtrans0(VL) % VLtrans0(VL) - moves an object into the origin of the coordinate system
% (by Tim Lueth, VLFL-Lib, 2012-MAI-02 as class: AUXILIARY PROCEDURES)
%
% This procedure move an object given as vertex list into coordinate
% system's center. All values of x,y,z are zero or positive. (Status of:
% 2017-01-29)
%
% See also: VLtransT, VLtransP, VLtrans1, VLtransR, VLtransT, VLtrans,
% VLtransN
%
% [VL,sx,sy,sz]=VLtrans0(VL)
% === INPUT PARAMETERS ===
% VL: Original vertex list
% === OUTPUT RESULTS ======
% VL: Vertex list
% sx: Size in x (also maximum value in x)
% sy: Size in y (also maximum value in y)
% sz: Size in z (also maximum value in z)
%
VLswapZX(VL)- z-axis becomes x-axis of a VL (y-rotation by -90 degree)
VLswapZX(VL) % VLswapZX(VL) - z-axis becomes x-axis of a VL (y-rotation by -90 degree)
% (by Tim Lueth, VLFL-Lib, 2012-MAI-02 as class: AUXILIARY PROCEDURES)
%
% y-rotation by -90 degree of a vertex list that [x y z] becomes [z y -x];
% This very fast fnctn is used if a 2D drawing is made in x/z and should
% be used in x/y.
% The name could also be: VLFLrotateX270, rotate270X
% Inverse procedure: VLswapXZ(VL)
%
% See also: VLswapYZ, VLswapZY, VLswapXY, VLswapYX, VLswapXZ, VLswapX,
% VLswapY, VLswapZ
%
% RVL=VLswapZX(VL)
% === INPUT PARAMETERS ===
% VL: Original vertex list
% === OUTPUT RESULTS ======
% RVL: Rotated vertex list.
%
VLswapXZ(VL)- x-axis becomes z-axis of a VL (y-rotation by +90 degree)
VLswapXZ(VL) % VLswapXZ(VL) - x-axis becomes z-axis of a VL (y-rotation by +90 degree)
% (by Tim Lueth, VLFL-Lib, 2012-MAI-02 as class: AUXILIARY PROCEDURES)
%
% y-rotation by +90 degree of a vertex list that [x y z] becomes [-z y x];
% This very fast fnctn is used if a 2D drawing is made in x/z and should
% be used in x/y.
% Inverse procedure: VLswapZX(VL)
%
% See also: VLswapYZ, VLswapZY, VLswapXY, VLswapYX, VLswapZX, VLswapX,
% VLswapY, VLswapZ
%
% RVL=VLswapXZ(VL)
% === INPUT PARAMETERS ===
% VL: Original vertex list
% === OUTPUT RESULTS ======
% RVL: Rotated vertex list.
%
VLFLclose3DC(VL,h)- Solid procedure to generate facets for ONE closed contour
VLFLclose3DC(VL,h) % VLFLclose3DC(VL,h) - Solid procedure to generate facets for ONE closed
% contour
% (by Tim Lueth, VLFL-Lib, 2012-APR-29 as class: SYNTHESIZING PROCEDURES)
%
% It is in principle identical to VLFLcloseC but supports also the 3rd
% dimension to generate a solid based on a height or a displacement
% vector. For closing objects with an outer and inner contour, used
% VLFLclose3D2C. The procedure nows supports also concave contours as
% long as they does not cross itself.
%
% [VL,FL]=VLFLclose3DC(VL,[h])
% === INPUT PARAMETERS ===
% VL: Vertex list or point list with 4 ore more points
% h: optional height or displacement vector; default is 0;
% === OUTPUT RESULTS ======
% VL: Vertex list (resorted)
% FL: Facet list
%
% EXAMPLE: Close a simple square:
% PL=[0 0 0; 10 0 0; 10 10 0; 0 10 0];
% [VL,FL]=VLFLcloseC (PL,5);
% [VL,FL]=VLFLcloseC (PL,[10;10;10]);
% VLFplot (VL,FL);
%
TPL(PL)- return for vertices of a patch the HT Matrix of the patch center
TPL(PL) % TPL(PL) - return for vertices of a patch the HT Matrix of the patch center
% (by Tim Lueth, VLFL-Lib, 2012-APR-27 as class: ANALYTICAL GEOMETRY)
%
% See also: TofR, TofVL, TofDPhiH, T3ofT2, T3P, T2P
%
% [T,X,n]=TPL(PL)
% === INPUT PARAMETERS ===
% PL: Point list or vertex list
% === OUTPUT RESULTS ======
% T: Transformation for Backtransformation
% X: Vertex list of transformed vertices
% n: length of vertex list
%
% EXAMPLE: UL=ULgenerate (VL,FL); % Generate a union/patch list
% PFL=FLofUL(UL,nr); % Take all facets of patch 1
% PVL=VL(PFL,:); % Make a list of vertices
% [T,XL]=TPL(PVL); % NOW TRANSFORM
% [GPL,ng]=VLGraham(XL); % Calculate Graham
% Y=(T*[GPL ones(size(GPL,1),1)]')'; GPL=Y(:,1:3) % Tranform back
%
exp_2012_04_27(dm,ms,nr)- More or less a simple test for TPL which is used for 3D Graham
exp_2012_04_27(dm,ms,nr) % exp_2012_04_27(dm,ms,nr) - More or less a simple test for TPL which is
% used for 3D Graham
% (by Tim Lueth, , 2012-APR-27)
%
% Experiment that reads in the testbody TEST-BIN3 (cuboid with included
% cylinder), doubles and merges the vertex list and facet list. Depending
% on the distance, patches will be attached to another. This experiment
% finds attached patches, calculate Graham and replaces the attached
% patches by one new one.
%
% [VL,UL]=exp_2012_04_27([dm,ms,nr])
% === INPUT PARAMETERS ===
% dm: Vector of displacement
% ms: Minimal patch size (union size)
% nr: Patch number
% === OUTPUT RESULTS ======
% VL: Vertex list
% UL: Union list
%
VLBezier4P(p1,p2,p3,p4,n);- simple function to calculate a 3D Bezier curve
VLBezier4P(p1,p2,p3,p4,n); % VLBezier4P(p1,p2,p3,p4,n); - simple fnctn to calculate a 3D Bezier curve
% (by Tim Lueth, VLFL-Lib, 2012-APR-25 as class: ANALYTICAL GEOMETRY)
%
% VL=VLBezier4P(p1,p2,p3,p4,[n]);
% === INPUT PARAMETERS ===
% p1: 1st point
% p2: 2nd point
% p3: 3rd point
% p4: 4th point
% n: number of supporting points
% === OUTPUT RESULTS ======
% VL: Vertex list of the bezier spline
%
% EXAMPLE: PL=[0 0 0; 5 0 0; 5 5 0; 0 10 0]
% VL=VLBezier4P(PL(1,:),PL(2,:),PL(3,:),PL(4,:),20); ;
% hold on; VLplot(VL), VLplot (PL)
%
exp_2012_04_21(fname,NR,size)- experiment for testing OLseparate & VLFLvertexfusion & ULgenerate & VLULplot
exp_2012_04_21(fname,NR,size) % exp_2012_04_21(fname,NR,size) - experiment for testing OLseparate &
% VLFLvertexfusion & ULgenerate & VLULplot
% (by Tim Lueth, VLFL-Lib, 2012-APR-21)
%
% Showing the power of ULgenerate
%
% [XVL,XFL,UL]=exp_2012_04_21([fname,NR,size])
% === INPUT PARAMETERS ===
% fname: File name on desktop
% NR: Object number in STL file
% size: Minimal size for a union area
% === OUTPUT RESULTS ======
% XVL: Vertex list of object
% XFL: Facet list of Object
% UL: Union list of Object
%
% EXAMPLE: Use the simple test body TEST-3
% exp_2012_04_21('TEST-BIN3',1,100);
% exp_2012_04_21('TEST-BIN3',2,100);
%
exp_2012_04_20 (of,f,ro,ri,dm)- This experiment is similar to exp_2012_04_19 but with additional helix structures
exp_2012_04_20 (of,f,ro,ri,dm) % exp_2012_04_20 (of,f,ro,ri,dm) - This experiment is similar to
% exp_2012_04_19 but with additional helix structures
% (by Tim Lueth, VLFL-Lib, 2012-APR-20)
%
% It generates a body with a solid inner structure, an outer structure
% using VLFLcorticalis and a set of shaped links using VLlink2P and
% VLFLexpandPL
%
% exp_2012_04_20([of,f,ro,ri,dm])
% === INPUT PARAMETERS ===
% of: Number of facets of a outer contour
% f: Number of facets of a inner contour
% ro: displacement point
% ri: Outer radius (edges)
% dm: Inner radius (edges)
%
% EXAMPLE: Generate a 30mm height cylindric object
% closeall; exp_2012_04_20(20,4,20,10,[0 0 0])
%
exp_2012_04_19 (of,f,ro,ri,dm)- This experiment is similar to exp_2012_04_16 but with shaped 'zigzag' links
exp_2012_04_19 (of,f,ro,ri,dm) % exp_2012_04_19 (of,f,ro,ri,dm) - This experiment is similar to
% exp_2012_04_16 but with shaped 'zigzag' links
% (by Tim Lueth, VLFL-Lib, 2012-APR-19)
%
% It generates a body with a solid inner structure, an outer structure
% using VLFLcorticalis and a set of shaped links using VLlink2P and
% VLFLexpandPL
%
% exp_2012_04_19([of,f,ro,ri,dm])
% === INPUT PARAMETERS ===
% of: Number of facets of a outer contour
% f: Number of facets of a inner contour
% ro: displacement point
% ri: Outer radius (edges)
% dm: Inner radius (edges)
%
% EXAMPLE: Generate a 30mm height cylindric object
% closeall; exp_2012_04_19(20,4,20,10,[0 0 0])
%
exp_2012_04_15 (of,f,ro,ri,dm)- This experiment is for closing contours
exp_2012_04_15 (of,f,ro,ri,dm) % exp_2012_04_15 (of,f,ro,ri,dm) - This experiment is for closing contours
% (by Tim Lueth, VLFL-Lib, 2012-APR-15)
%
% It shows how to generate closed contours for polygons with arbitrary
% inner and outer edges
%
% exp_2012_04_15([of,f,ro,ri,dm])
% === INPUT PARAMETERS ===
% of: Number of facets of a outer contour
% f: Number of facets of a inner contour
% ro: displacement point
% ri: Outer radius (edges)
% dm: Inner radius (edges)
%
% EXAMPLE: Generate a 30mm height cylindric object
% exp_2012_04_15 (40,6,10,3,[5 0 5])
%
VLFLclose(OVL,IVL)- Closes an contour right hand with an optional second contour
VLFLclose(OVL,IVL) % VLFLclose(OVL,IVL) - Closes an contour right hand with an optional
% second contour
% (by Tim Lueth, VLFL-Lib, 2012-APR-15 as class: SYNTHESIZING PROCEDURES)
%
% Powerful procedure that is used to close a contour, or close a contour
% with an inner contour or to generate the hull between an lower(outer)
% and upper(inner contour) with arbitrary number of edges. It is used in
% FLcoatVLEL (5.1.2013) !!! Procedure still seems to have a bug for
% contours in the same plane. It is possible that in 2D an edge can cross
% the inner contour. Check with 3 outer and 7 inner facets. But for
% contours in different planes it is better than Delaunay triangulation
% FLofVLEL (Delaunay) (Status of: 2013-01-06)
%
% [VL,FL]=VLFLclose(OVL,IVL)
% === INPUT PARAMETERS ===
% OVL: Outer contour vertex list (outer, bottom) (3D)
% IVL: Inner contour certex list (inner, top) (3D)
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
exp_2012_04_16 (of,f,ro,ri,dm)- This experiment is for closing contours
exp_2012_04_16 (of,f,ro,ri,dm) % exp_2012_04_16 (of,f,ro,ri,dm) - This experiment is for closing contours
% (by Tim Lueth, VLFL-Lib, 2012-APR-15)
%
% It shows how to generate closed contours for polygons with arbitrary
% inner and outer edges
%
% exp_2012_04_16([of,f,ro,ri,dm])
% === INPUT PARAMETERS ===
% of: Number of facets of a outer contour
% f: Number of facets of a inner contour
% ro: displacement point
% ri: Outer radius (edges)
% dm: Inner radius (edges)
%
% EXAMPLE: EXAMPLE: Generate two simple objects
% closeall; exp_2012_04_16 (4,10,20,10,[0 0 0])
% closeall; exp_2012_04_16 (4,20,20,10,[0 0 0])
% closeall; exp_2012_04_16 (20,4,20,10,[0 0 0])
%
VLswapYZ(VL)- y-axis becomes z-axis of a VL (x-rotation by +90 degree)
VLswapYZ(VL) % VLswapYZ(VL) - y-axis becomes z-axis of a VL (x-rotation by +90 degree)
% (by Tim Lueth, VLFL-Lib, 2012-APR-14 as class: AUXILIARY PROCEDURES)
%
% x-rotation by +90 degree of a vertex list that [x y z] becomes [x -z y]
% This very fast fnctn is used if a 2D drawing is made in x/y and should
% be used in x/z.
% The name could also be: VLFLrotateX090, rotate090x
% Inverse procedure: VLswapZY(VL)
%
% See also: VLswapYZ, VLswapZY, VLswapXY, VLswapYX, VLswapZX, VLswapXZ,
% VLswapX, VLswapY, VLswapZ
%
% RVL=VLswapYZ(VL)
% === INPUT PARAMETERS ===
% VL: Original vertex list
% === OUTPUT RESULTS ======
% RVL: Rotated vertex list.
%
VLswapZY(VL,n)- z-axis becomes y-axis of a VL (x-rotation by +90 degree)
VLswapZY(VL,n) % VLswapZY(VL,n) - z-axis becomes y-axis of a VL (x-rotation by +90
% degree)
% (by Tim Lueth, VLFL-Lib, 2012-APR-14 as class: AUXILIARY PROCEDURES)
%
% x-rotation by -90 degree of a vertex list that [x y z] becomes [x z -y];
% This very fast procedure is used if a 2D drawing is made in x/z and
% should be used in x/y.
% The name could also be: VLFLrotateX270, rotate270X
% Inverse procedure: VLswapYZ(VL)
%
% RVL=VLswapZY(VL,[n])
% === INPUT PARAMETERS ===
% VL: Original vertex list
% n: optional nr of repeated cylces, default is 1
% === OUTPUT RESULTS ======
% RVL: Rotated vertex list.
%
VLswapXY(VL)- x-axis becomes y-axis of a VL (z-rotation by 90 degree)
VLswapXY(VL) % VLswapXY(VL) - x-axis becomes y-axis of a VL (z-rotation by 90 degree)
% (by Tim Lueth, VLFL-Lib, 2012-APR-14 as class: AUXILIARY PROCEDURES)
%
% z-rotation by +90 degree of a vertex list that [x y z] becomes [y -x z];
% This very fast fnctn is used if a 2D/3D drawing should be rotated 90
% degree around z.
% The name could also be: VLFLrotateZ090, rotate090z
% Inverse procedure: VLswapYZ(VL)
%
% See also: VLswapYZ, VLswapZY, VLswapYX, VLswapZX, VLswapXZ, VLswapX,
% VLswapY, VLswapZ
%
% RVL=VLswapXY(VL)
% === INPUT PARAMETERS ===
% VL: Original vertex list
% === OUTPUT RESULTS ======
% RVL: Rotated vertex list.
%
VLswapYX(VL)- y-axis becomes x-axis of a VL (z-rotation by -90 degree)
VLswapYX(VL) % VLswapYX(VL) - y-axis becomes x-axis of a VL (z-rotation by -90 degree)
% (by Tim Lueth, VLFL-Lib, 2012-APR-14 as class: AUXILIARY PROCEDURES)
%
% z-rotation by -90 degree of a vertex list that [x y z] becomes [y -x z];
% This very fast fnctn is used if a 2D/3D drawing should be rotated 90
% degree around z.
% The name could also be: VLFLrotateZ270, rotate270z
% Inverse procedure: VLswapXY(VL)
%
% See also: VLswapYZ, VLswapZY, VLswapXY, VLswapZX, VLswapXZ, VLswapX,
% VLswapY, VLswapZ
%
% RVL=VLswapYX(VL)
% === INPUT PARAMETERS ===
% VL: Original vertex list
% === OUTPUT RESULTS ======
% RVL: Rotated vertex list.
%
exp_2012_04_13(of,f,dm)- generates a STL test body using VLELcorticalis
exp_2012_04_13(of,f,dm) % exp_2012_04_13(of,f,dm) - generates a STL test body using VLELcorticalis
% (by Tim Lueth, VLFL-Lib, 2012-APR-14)
%
% This is a simple procedure to generate testbodies using the corticalis
% procedure
%
% [A,B,C]=exp_2012_04_13([of,f,dm])
% === INPUT PARAMETERS ===
% of: Number of facets of a outer contour
% f: Number of facets of a inner contour
% dm: displacement point
% === OUTPUT RESULTS ======
% A:
% B:
% C:
%
VLpolygon(f,rx,ry,dm)- returns the points of a polygon as vertex list
VLpolygon(f,rx,ry,dm) % VLpolygon(f,rx,ry,dm) - returns the points of a polygon as vertex list
% (by Tim Lueth, VLFL-Lib, 2012-APR-12)
%
% The radius is used for the edges not for the vertices
%
% VL=VLpolygon(f,rx,[ry,dm])
% === INPUT PARAMETERS ===
% f: Number of point/lines/facets/edes
% rx: radius in x
% ry: optional radius in y, default is rx
% dm: optional center vertex for moving the polygon; default is [0 0 0];
% === OUTPUT RESULTS ======
% VL: Vertex list of the polygon
%
VLFLofrangez(VL,FL,z1,z2,sname)- returns a reduced facet list and resorted vertex list for all facets of a specified plane
VLFLofrangez(VL,FL,z1,z2,sname) % VLFLofrangez(VL,FL,z1,z2,sname) - returns a reduced facet list and
% resorted vertex list for all facets of a specified plane
% (by Tim Lueth, VLFL-Lib, 2012-APR-11 as class: ANALYZING PROCEDURES)
%
% This procedure reduces the facet list to those facets that cross or
% touch a defined z-plane. In addition, the vertex list is sorted by z,
% x, y. The procedure is used for accelerating the VLELsclicer. In this
% case z2=z1 always. (Status of: 2013-08-15)
%
% [RVL,RFL]=VLFLofrangez(VL,FL,[z1,z2,sname])
% === INPUT PARAMETERS ===
% VL: Original vertex list
% FL: Original facet list
% z1: z coordinate of the slice
% z2: second z-coordinate, default is z1
% sname: optional name for generating a printed protocol
% === OUTPUT RESULTS ======
% RVL: Reduced and sorted vertex list (z)
% RFL: Reduced and sorted facet list (index)
%
exp_2012_04_09(fname,mag,minz,maxz,nums)- Experiment to test procedures such as VLLLslicer(VL,FL,z) and VLGraham(VL)
exp_2012_04_09(fname,mag,minz,maxz,nums) % exp_2012_04_09(fname,mag,minz,maxz,nums) - Experiment to test
% procedures such as VLLLslicer(VL,FL,z) and VLGraham(VL)
% (by Tim Lueth, VLFL-Lib, 2012-APR-09)
%
% The STL file is sliced with respect to the parameters. In each slice,
% the crossing points of all facets are calculated. Finally the Graham
% algorithm for convex hull is applied.
%
% [VL,FL,CVL,CLL,NL,CHVL]=exp_2012_04_09([fname,mag,minz,maxz,nums])
% === INPUT PARAMETERS ===
% fname: Filename, default is 'exp_2012_04_09' for the prisma
% mag: magnification (1=mm, 1000=m)
% minz: minimal z value for slicing, default is min(STL)
% maxz: maximal z value for slicing, default is min(STL)
% nums: number of slices; default is ~ slice distance=1 mm
% === OUTPUT RESULTS ======
% VL: Vertex List of the STL file
% FL: Facet List of the STL file
% CVL: Crossing vertex list of the selected slice
% CLL: Crossing line list of the selected slice
% NL: Normal vector list of the crossing lines
% CHVL: Sorted vertex list of the convex hull
%
% EXAMPLE: Generate a binary STL-File of a simple geometry and generate
% convex hull inside and outside
% [VL,FL,CVL,CLL,NL,PL]=exp_2012_04_09 ('',1,0,0);
% VLLLplot (CVL,CLL,'r.-',NL)
%
PRplot- simply prints the plot similar to print
PRplot % PRplot - simply prints the plot similar to print
% (by Tim Lueth, VLFL-Lib, 2012-APR-09 as class: VISUALIZATION)
%
% This procedure print the current figure using the print command. It
% simply adds the datestr, and labels for the axes. (Status of:
% 2017-03-05)
%
% See also: snapplot, copyplot, snapnow, drawnow, smbdrawnow
%
% PRplot
%
% EXAMPLE: Print the figure
% pplot ([[0;0;0] [10;10;10]],'r')
% grid on
% prplot
%
exp_2012_04_10(fname,sname,d)- Experiment generates test bodies for fitting experiments
exp_2012_04_10(fname,sname,d) % exp_2012_04_10(fname,sname,d) - Experiment generates test bodies for
% fitting experiments
% (by Tim Lueth, VLFL-Lib, 2012-APR-09)
%
% The procedure writes a binary STL file that contains the physical test.
% Ordered at Shapways.com April, 9th. 7 different slot sizes are
% considered. 0.0 0.05 0.10 0.15 0.20 0.25 0.3. In addition the resultion
% is 0.01. The real particle size is 0.05.
%
% [VL,FL]=exp_2012_04_10([fname,sname,d])
% === INPUT PARAMETERS ===
% fname: file name; default is exp_2012_04_10
% sname: Experiment string; default is 'TL:MMXII-IV-X:'
% d: minimal spacial resultion; default is 0.01
% === OUTPUT RESULTS ======
% VL: Vertex list of the object
% FL: Facet list of the object
%
VLELchecker (VL,EL,d,stext)- performs different tests on edge structures and displays the results
VLELchecker (VL,EL,d,stext) % VLELchecker (VL,EL,d,stext) - performs different tests on edge
% structures and displays the results
% (by Tim Lueth, VLFL-Lib, 2012-APR-09)
%
% VLELchecker(VL,EL,d,[stext])
% === INPUT PARAMETERS ===
% VL: Vertex list
% EL: Corresponding edge list
% d: Detail of protocoll; default is full
% stext: optional string for output protocoll
%
VLELslicer2(VL,FL,z)- returns the crossing vertices and lines of a sliced object
VLELslicer2(VL,FL,z) % VLELslicer2(VL,FL,z) - returns the crossing vertices and lines of a sliced object
% (by Tim Lueth, VLFL-Lib, 12-APR-08 as class: ANALYZING PROCEDURES)
%
% =======================================================================
% OBSOLETE (2017-03-20) - USE FAMILY 'CPLofSGslice, PLELofCPL' INSTEAD
% =======================================================================
%
% The procedure calculates the crossing points of an object given by
% vertex list and facet list. Two situations are ignored. If a facet has
% just one crossing point (tip) and if a facet has three crossing points
% (fully in plane). The procedure needs optimization somehow one day.
% (Status of: 2017-03-20)
%
% See also: [ CPLofSGslice, PLELofCPL ] ; slcplotVLFL, VLELslicer
%
% [CVL,CEL,NL]=VLELslicer2(VL,FL,z)
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% z: z value for slicing
% === OUTPUT RESULTS ======
% CVL: Crossing vertex list of the selected slice
% CEL: Crossing line list of the selected slice
% NL: Normal vector list of the crossing lines
%
% EXAMPLE: Generate a simple octagon (5x5x20)
% [VL,FL]=VLFLcylinder(20,5/cos(pi/8),8-1,1);
% [CVL,CLL,NL]=VLELslicer (VL,FL,0)
% VLELplot (CVL,CLL,'r*-',NL);
%
exp_2012_04_08(fname,mag,minz,maxz,nums)- More complex processing of a STL-Files to generate a convex hull
exp_2012_04_08(fname,mag,minz,maxz,nums) % exp_2012_04_08(fname,mag,minz,maxz,nums) - More complex processing of a
% STL-Files to generate a convex hull
% (by Tim Lueth, VLFL-Lib, 2012-APR-08)
%
% The STL file is sliced either with 1 mm distance or related to number
% of requested slices. In each slice, the crossing point of all facets is
% calucated.
% Afterwards the Graham algorith for convex hull is applied
%
% [VL,FL,CVL,CLL,NL,PL]=exp_2012_04_08([fname,mag,minz,maxz,nums])
% === INPUT PARAMETERS ===
% fname: Filename, default is 'exp_2012_04_08' for the prisma
% mag: magnification (1=mm, 1000=m)
% minz: minimal z value for slicing, default is min(STL)
% maxz: maximal z value for slicing, default is min(STL)
% nums: number of slices; default is ~ slice distance=1 mm
% === OUTPUT RESULTS ======
% VL: Vertex List of the STL file
% FL: Facet List of the STL file
% CVL: Crossing vertex list of the selected slice
% CLL: Crossing line list of the selected slice
% NL: Normal vector list of the crossing lines
% PL: Sorted Point list of the convex hull
%
% EXAMPLE: READ an binary STL-File and generate
% [VL,FL,CVL,CLL,NL,PL]=exp_2012_04_08 ('TEST-BIN1',1,-62,-20,10);
% pplot (PL,'m-')
%
VLELslicer(VL,FL,z)- returns the crossing vertices and lines of a sliced object
VLELslicer(VL,FL,z) % VLELslicer(VL,FL,z) - returns the crossing vertices and lines of a sliced object
% (by Tim Lueth, VLFL-Lib, 2012-APR-08 as class: ANALYZING PROCEDURES)
%
% =======================================================================
% OBSOLETE (2017-03-20) - USE FAMILY 'CPLofSGslice, PLELofCPL' INSTEAD
% =======================================================================
%
% The procedure calculates the crossing points of an object given by
% vertex list and facet list. Two situations are ignored. If a facet has
% just one crossing point (tip) and if a facet has three crossing points
% (fully in plane). The procedure needs optimization somehow one day.
% (Status of: 2017-03-20)
%
% See also: [ CPLofSGslice, PLELofCPL ] ; slcplotVLFL, VLELslicer2
%
% [CVL,CLL,NL]=VLELslicer(VL,FL,z)
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% z: z value for slicing
% === OUTPUT RESULTS ======
% CVL: Crossing vertex list of the selected slic
% CLL: Crossing line list of the selected slice
% NL: Normal vector list of the crossing lines
%
% EXAMPLE: Generate a simple octagon (5x5x20)
% [VL,FL]=VLFLcylinder(20,5/cos(pi/8),8-1,1);
% [CVL,CLL,NL]=VLELslicer (VL,FL,0)
% VLELplot (CVL,CLL,'r*-',NL);
%
VLFLwriteSTLb (VL,FL,FNAME,ONAME)- writes a STL object in binary mode given by a vertex list and facet list into a STL-file
VLFLwriteSTLb (VL,FL,FNAME,ONAME) % VLFLwriteSTLb (VL,FL,FNAME,ONAME) - writes a STL object in binary mode
% given by a vertex list and facet list into a STL-file
% (by Tim Lueth, VLFL-Lib, 2012-APR-07 as class: FILE HANDLING)
%
% Fast and reliable procedure. Not tested with all Modelers. Works with
% MESHLAB. (Status of: 2016-12-27)
%
% See also: SGreadSTL, SGwriteSTL, VLFLreadSTL, VLFLwriteSTL, STLAsctoBin
%
% VLFLwriteSTLb(VL,FL,[FNAME,ONAME])
% === INPUT PARAMETERS ===
% VL: Vertex list
% FL: Facet list
% FNAME: Name of the desired file on Desktop
% ONAME: Name of the STL object
%
% EXAMPLE: Generate a simple binary file of a cuboid
% [OVL,OFL]=VLFLcylinder(10,5,3,1);
% VLFLwriteSTLb (OVL,OFL,'PRISMA-BIN','by Tim C. Lueth');
%
exp_2012_04_07(fname,mag,minz,maxz,nums)- Analyzes a STL-Files to generate a convex hull
exp_2012_04_07(fname,mag,minz,maxz,nums) % exp_2012_04_07(fname,mag,minz,maxz,nums) - Analyzes a STL-Files to
% generate a convex hull
% (by Tim Lueth, VLFL-Lib, 2012-APR-07)
%
% The STL file is sliced either with 1 mm distance or related to number
% of requested slices. In each slice, the crossing point of all facets is
% calucated.
% Afterwards the Graham algorith for convex hull is applied
%
% [VL,FL,PC,PCL]=exp_2012_04_07([fname,mag,minz,maxz,nums])
% === INPUT PARAMETERS ===
% fname: Filename, default is 'exp_2012_04_07' for the prisma
% mag: magnification (1=mm, 1000=m)
% minz: minimal z value for slicing, default is min(STL)
% maxz: maximal z value for slicing, default is min(STL)
% nums: number of slices; default is ~ slice distance=1 mm
% === OUTPUT RESULTS ======
% VL: Vertex List of the STL file
% FL: Facet List of the STL file
% PC:
% PCL:
%
VLGraham(VL)- returns the convex hull of a point list by Graham
VLGraham(VL) % VLGraham(VL) - returns the convex hull of a point list by Graham
% (by Tim Lueth, VLFL-Lib, 2012-APR-07 as class: ANALYZING PROCEDURES)
%
% This procedure calculates from an unsorted point list the sorted point
% list of the convex hull related to the Graham Algorithms (1972). It is
% a powerful fnctn.
% Remember also important list fnctns such as: unique, union, intersect,
% setdiff, ismember. (Status of: 2017-03-19)
%
% See also: VLGrahamPVL
%
% [CHVL,n]=VLGraham(VL)
% === INPUT PARAMETERS ===
% VL: Unsorted point list
% === OUTPUT RESULTS ======
% CHVL: Sorted point list of the convex hull
% n: length of the convex hull
%
VLsortC(VL,d)- returns a point list that is sorted around its' center
VLsortC(VL,d) % VLsortC(VL,d) - returns a point list that is sorted around its' center
% (by Tim Lueth, VLFL-Lib, 2012-APR-07 as class: AUXILIARY PROCEDURES)
%
% [VL,WL,DL]=VLsortC(VL,[d])
% === INPUT PARAMETERS ===
% VL: Original point list
% d: order same angle: 'outer' | 'inner'; default is 'inner'
% === OUTPUT RESULTS ======
% VL: Sorted point list
% WL: Angle list
% DL: Distance list
%
% EXAMPLE: Show the difference of the order:
% [VL,FL,CVL,CLL,NL,PL]=exp_2012_04_09 ('',1,0,0);
% A=sortrows(CVL,[1,2,3]); % unsorted list
% VLplot (A,'r-'), hold on % show the unsorted list
% VLplot (VLsortC(A),'b-') % outer points first
% VLplot (VLsortC(A,'inner'),'k.-') % inner points first
%
VLplot(VL,c,w,vec);- plots different views of a vertex list (nx3)
VLplot(VL,c,w,vec); % VLplot(VL,c,w,vec); - plots different views of a vertex list (nx3)
% (by Tim Lueth, VLFL-Lib, 2012-APR-07 as class: VISUALIZATION)
%
% This fnctn is used very often and is based on plot3 or lplot. (Status
% of: 2017-03-20)
%
% See also: VLplot, VLscatter, textVL
%
% h=VLplot(VL,[c,w,vec]);
% === INPUT PARAMETERS ===
% VL: Vertex list
% c: optional color; default is 'r.-'
% w: plot size
% vec: if v>0, vectors are plotted from the origin
% === OUTPUT RESULTS ======
% h: handle
%
VLFLreadSTL(FName,mag)- reads an ascii STL-File as vertex & facet list
VLFLreadSTL(FName,mag) % VLFLreadSTL(FName,mag) - reads an ascii STL-File as vertex & facet list
% (by Tim Lueth, VLFL-Lib, 2012-APR-06 as class: FILE HANDLING)
%
% Based on a procedure of 2010-Oct. This procedure was under devlopment
% since the method [VL,j,j1,j2,j3]=VLcat(VL,NVL) seems to be not
% effective enough. The final method is now, first to read all vertices
% as list. Later the 'unique' command is used to generate a complete
% vertex list and facet list from the original data. (Status of:
% 2017-03-20)
%
% See also: SGreadSTL, SGwriteSTL, VLFLwriteSTL, STLAsctoBin
%
% [VL,FL,S1,S2,STL]=VLFLreadSTL(FName,[mag])
% === INPUT PARAMETERS ===
% FName: Filename of the STL-File (ASCII)
% mag: magnification factor
% === OUTPUT RESULTS ======
% VL: Vertex List
% FL: Facet List
% S1: solid string
% S2: endsolid string
% STL: The original facet list that uses no vertex list
%
% EXAMPLE: Generate a simple block, write it into a file, read it from
% the file and write it a second time.
% [VL,FL]=VLFLcylinder(10,5,3,1);
% VLFLwriteSTL ('PRISMA','by Tim C. Lueth',VL,FL);
% [NVL,NFL]=VLFLreadSTL ('PRISMA');
% VLFLwriteSTL ('PRISMA-COPY','by Tim C. Lueth',NVL,NFL);
%
exp_2012_04_06(fname)- Experiment for testing binary STL files
exp_2012_04_06(fname) % exp_2012_04_06(fname) - Experiment for testing binary STL files
% (by Tim Lueth, VLFL-Lib, 2012-APR-06 as class: EXPERIMENTS)
%
% This prodecure tests the VLFLreadSTL prcedure by reading in a given
% STL. If no STL is given, the procedure generates a STL file first and
% reads it in afterwards. (Status of: 2012-11-04)
%
% [VL,FL]=exp_2012_04_06([fname])
% === INPUT PARAMETERS ===
% fname: Optional file name, default is 'exp_2012_04_06'
% === OUTPUT RESULTS ======
% VL: Vertex list of the read file
% FL: Facet list of the read file
%
% EXAMPLE: Generate a simple bar and copy it
% exp_2012_04_06
%
VLFLreadSTLb(FName)- reads a STL-File in binary format
VLFLreadSTLb(FName) % VLFLreadSTLb(FName) - reads a STL-File in binary format
% (by Tim Lueth, VLFL-Lib, 2012-APR-06 as class: FILE HANDLING)
%
% Quite fast fnctn to read a STL in binary format (Status of: 2016-12-27)
%
% See also: SGreadSTL, SGwriteSTL, VLFLreadSTL, VLFLwriteSTL, STLAsctoBin
%
% [VL,FL,H,n]=VLFLreadSTLb(FName)
% === INPUT PARAMETERS ===
% FName: Filename
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% H: Header 80 Uint8
% n: Number of triangles
%
% EXAMPLE: Simply loads a file from Desktop:
% [VL,FL]=VLFLreadSTLb ('TEST-BIN1');
%
exp_2012_03_24(fname,dr,initials)- Writes a STL File of different light weigth structures
exp_2012_03_24(fname,dr,initials) % exp_2012_03_24(fname,dr,initials) - Writes a STL File of different
% light weigth structures
% (by Tim Lueth, VLFL-Lib, 2012-MÄR-24 as class: EXPERIMENTS)
%
% This procedure is a simple test for using the procedure exp_2012_03_21
% / VLFLellipse3. Different spheres are generated and the lagest one gets
% a small name tag. (Status of: 2012-11-04)
%
% [VL,FL]=exp_2012_03_24([fname,dr,initials])
% === INPUT PARAMETERS ===
% fname: Final file name; default is 'exp_2012_03_24-4'
% dr: Thickness of the used spheres
% initials: Intials default is TL
% === OUTPUT RESULTS ======
% VL: Vertex list of the final structure
% FL: Facet list of the final structure
%
VLFLchecker(VL,FL,long)- performs a check of the vertex list and facet list to detect non manifold problems
VLFLchecker(VL,FL,long) % VLFLchecker(VL,FL,long) - performs a check of the vertex list and facet
% list to detect non manifold problems
% (by Tim Lueth, VLFL-Lib, 2012-MÄR-22 as class: CHECKING PROCEDURES)
%
% This procedures generates a simple protocol on the status of the vertex
% list and facet list. It should allow to detect non manifold problems
% for generating the files and to speed up development.
% It generates an terminal output using FID=1.
%
% [VLC,EL,PEL]=VLFLchecker(VL,FL,[long])
% === INPUT PARAMETERS ===
% VL: Vertex list of the object
% FL: Facet list of the object
% long: true==exact error messages; default is false
% === OUTPUT RESULTS ======
% VLC: List of sorted vertices to analyze the problematic vertices
% EL: List of sorted edges to analyze the problematic edges
% PEL: List of non-manifold edges
%
% EXAMPLE: Show the non-manifold edges of a solid:
% [VLC,EL,PEL]=VLFLchecker(VL,FL);
% VLFLELplot (VL,PEL);
%
exp_2012_03_21(fname,rx,ry,rz,dr,nc,na,nb)- Simple first experiment to generate a hollow sphere
exp_2012_03_21(fname,rx,ry,rz,dr,nc,na,nb) % exp_2012_03_21(fname,rx,ry,rz,dr,nc,na,nb) - Simple first experiment to
% generate a hollow sphere
% (by Tim Lueth, VLFL-Lib, 2012-MÄR-21)
%
% [VL,FL]=exp_2012_03_21([fname,rx,ry,rz,dr,nc,na,nb])
% === INPUT PARAMETERS ===
% fname: STL file name, default is: 'exp_2012_03_21-1'
% rx: Radius in X of the sphere
% ry: Radius in Y of the sphere
% rz: Radius in Z of the sphere
% dr: Thickness of the sphere
% nc: Number of Pattern, default is
% na: Number of closed planes
% nb: Number of open planes
% === OUTPUT RESULTS ======
% VL: Vertex list of the overall object
% FL: Facet list of the overall object
%
% EXAMPLE: Some useful Geometries:
% [VL,FL]=exp_2012_03_21('exp_2012_03_21-1',20,20,20,1,20,3,1); % 40mm
% ball, 1mm wall, 20*1:1
%
VLFLellipse3(rx,ry,rz,dr,nc,na,nb)- returns light weight structure of a closed sphere or ellipsoid
VLFLellipse3(rx,ry,rz,dr,nc,na,nb) % VLFLellipse3(rx,ry,rz,dr,nc,na,nb) - returns light weight structure of
% a closed sphere or ellipsoid
% (by Tim Lueth, VLFL-Lib, 2012-MÄR-21)
%
% [VL,FL]=VLFLellipse3([rx,ry,rz,dr,nc,na,nb])
% === INPUT PARAMETERS ===
% rx: Radius in X of the sphere
% ry: Radius in Y of the sphere
% rz: Radius in Z of the sphere
% dr: Thickness of the sphere
% nc: Number of Pattern, default is
% na: Number of closed planes
% nb: Number of open planes
% === OUTPUT RESULTS ======
% VL: Vertex list of the overall object
% FL: Facet list of the overall object
%
% EXAMPLE: Some useful Geometries:
% [VL,FL]=exp_2012_03_21('exp_2012_03_21-1',20,20,20,1,20,3,1); % 40mm
% ball, 1mm wall, 20*1:1
% [VL,FL]=exp_2012_03_21('exp_2012_03_21-1',10,10,10,1,6); % 10mm, 6 patt
%
VLtrans1(VL)- moves an object into the first quadrant
VLtrans1(VL) % VLtrans1(VL) - moves an object into the first quadrant
% (by Tim Lueth, VLFL-Lib, 2012-MÄR-11 as class: AUXILIARY PROCEDURES)
%
% This procedure move an object given as vertex list into the first
% coordinate system's quadrant. All values of x,y,z are zero or positive.
%
% See also: VLtransT, VLtransP, VLtrans0, VLtransR, VLtransT, VLtrans,
% VLtransN
%
% [VL,sx,sy,sz]=VLtrans1(VL)
% === INPUT PARAMETERS ===
% VL: Original vertex list
% === OUTPUT RESULTS ======
% VL: Vertex list; no value is smaller than 0
% sx: Size in x (also maximum value in x)
% sy: Size in y (also maximum value in y)
% sz: Size in z (also maximum value in z)
%
exp_2012_03_11(fname,sname)- Simple first experiment to generate box of different size and to arrange them in space
exp_2012_03_11(fname,sname) % exp_2012_03_11(fname,sname) - Simple first experiment to generate box
% of different size and to arrange them in space
% (by Tim Lueth, VLFL-Lib, 2012-MÄR-11)
%
% [VL,FL]=exp_2012_03_11([fname,sname])
% === INPUT PARAMETERS ===
% fname: STL file name, default is: 'exp_2012_02_05-1'
% sname: Date fries of the experimental board, default
% is:'TL:MMXII-II-V:I'
% === OUTPUT RESULTS ======
% VL: Vertex list of the overall object
% FL: Facet list of the overall object
%
% EXAMPLE: Generate three Boxes with 2 mm bars of [40;30;20] and
% [30;20;10] and [70;40;35] and have a slot of 2 among them
% exp_2012_03_11('exp_2012_03_11-1');
%
exp_2012_02_10(fname,sname,tl,fw,tw)- Experiment to generate internal gears for a Futaba S3156 servo motor
exp_2012_02_10(fname,sname,tl,fw,tw) % exp_2012_02_10(fname,sname,tl,fw,tw) - Experiment to generate internal
% gears for a Futaba S3156 servo motor
% (by Tim Lueth, VLFL-Lib, 2012-FEB-10 as class: EXPERIMENTS)
%
% Instead of using a rod to connect a servo motor to a 3D-printed
% structure, it makes sense to insert the motor axis, which has an
% external gear, into a socket with an internal gear. This procedure
% generates an experimental board consisting of 25 different internal
% gear with a
% tooth lenght of [0.3 0.35 0.4 0.45 0.5] and a
% foot width of [0.4 0.5 0.6 0.7 0.8] (Status of: 2012-11-04)
%
% [VL,FL]=exp_2012_02_10([fname,sname,tl,fw,tw])
% === INPUT PARAMETERS ===
% fname: STL file name, default is: 'exp_2012_02_05-1'
% sname: Date fries of the experimental board, default
% is:'TL:MMXII-II-V:I'
% tl:
% fw:
% tw:
% === OUTPUT RESULTS ======
% VL: Vertex list of the experimental board
% FL: Vertex list of the experimental board
%
% EXAMPLE: Generates a experimantal board to test the internal gear
% interface with the Futaba S3156 servo motor
% exp_2012_02_05('exp_2012_02_05-1','TL:MMXII-II-V:I');
%
exp_2012_02_05(fname,sname)- Experiment to generate internal gears for a Futaba S3156 servo motor
exp_2012_02_05(fname,sname) % exp_2012_02_05(fname,sname) - Experiment to generate internal gears for
% a Futaba S3156 servo motor
% (by Tim Lueth, VLFL-Lib, 2012-FEB-05)
%
% Instead of using a rod to connect a servo motor to a 3D-printed
% structure, it makes sense to insert the motor axis, which has an
% external gear, into a socket with an internal gear. This procedure
% generates an experimental board consisting of 25 different internal
% gear with a
% tooth lenght of [0.3 0.35 0.4 0.45 0.5] and a
% foot width of [0.4 0.5 0.6 0.7 0.8]
%
% [VL,FL]=exp_2012_02_05([fname,sname])
% === INPUT PARAMETERS ===
% fname: STL file name, default is: 'exp_2012_02_05-1'
% sname: Date fries of the experimental board, default
% is:'TL:MMXII-II-V:I'
% === OUTPUT RESULTS ======
% VL: Vertex list of the experimental board
% FL: Vertex list of the experimental board
%
% EXAMPLE: Generates a experimantal board to test the internal gear
% interface with the Futaba S3156 servo motor
% exp_2012_02_05('exp_2012_02_05-1','TL:MMXII-II-V:I');
%
VLFLgear(H,R,n,tl,fw,tw)- returns the vertex/facet list for the gear teeth of an internal or external gear
VLFLgear(H,R,n,tl,fw,tw) % VLFLgear(H,R,n,tl,fw,tw) - returns the vertex/facet list for the gear
% teeth of an internal or external gear
% (by Tim Lueth, VLFL-Lib, 2012-FEB-04)
%
% The procedure generates simply a number of gar teeth for an internal
% gear or an external gear. The resulting vertex/facet list has to
% concatenated with a cylinder / tube to become a complete gear.
%
% [VL,FL]=VLFLgear([H,R,n,tl,fw,tw])
% === INPUT PARAMETERS ===
% H: Height of the gear, default is 3
% R: Radius of the gear (Outer/internal, and Inner/external gears)
% n: Number of teeth, default is 20
% tl: Tooth lenght (negative/internal gear, positive/external gear)
% fw: Tooth foot width
% tw: Tooth tip width, default is fw
% === OUTPUT RESULTS ======
% VL: Vertex list of the gear teeth
% FL: Facet list of the gear teeth
%
exp_2012_02_01(fname,sname,n,lw,wt,mr,dt,dr)- returns a structure with tube of length 50 with different wall thickness and diameter
exp_2012_02_01(fname,sname,n,lw,wt,mr,dt,dr) % exp_2012_02_01(fname,sname,n,lw,wt,mr,dt,dr) - returns a structure with
% tube of length 50 with different wall thickness and diameter
% (by Tim Lueth, VLFL-Lib, 2012-FEB-01)
%
% This experiment should show the flexibility of tube of length 50mm,
% 0.5mm wall and about 2 mm diameter. The procedure is similar to the
% experiment 2011-12-27:2
% Wall [0.5 0.6 0.7 0.8] Inner Diameter [1 2 3 4] n=40;
%
% [VL,FL]=exp_2012_02_01([fname,sname,n,lw,wt,mr,dt,dr])
% === INPUT PARAMETERS ===
% fname: String-Name; default 'TL:MMXII-I-XXXI'; default exp_2012_01_31_1
% sname: String-Name; default 'TL:MMXII-I-XXXI:I'
% n: number of facets, default 40
% lw: Number of light weight bars, default 0
% wt: Wall thickness, default is 0.5
% mr: Radius of the hole, default is 0.5
% dt: step size of the wall thickness, default is 0.1
% dr: step size of hole radius in the middle, default is 0.5
% === OUTPUT RESULTS ======
% VL: Vertex list of the structure
% FL: Facet list of the structure
%
% EXAMPLE: Generate thin wall structures of different diameters:
% exp_2012_01_31 ('1','TL:MMXII-II-I:I',40,0,0.7,0.5,0.1,0.5)
% exp_2012_01_31 ('2','TL:MMXII-II-I:II',4,0,0.7,0.5,0.1,0.5)
% exp_2012_01_31 ('3','TL:MMXII-II-I:III',40,3,0.7,0.5,0.1,0.5)
% exp_2012_01_31 ('4','TL:MMXII-II-I:IV',40,4,0.7,0.5,0.1,0.5)
% exp_2012_01_31 ('5','TL:MMXII-II-I:V',40,5,0.7,0.5,0.1,0.5)
%
exp_2012_01_31(fname,sname,n,lw)- returns a structure with tube of length 70 with different wall thickness and diameter
exp_2012_01_31(fname,sname,n,lw) % exp_2012_01_31(fname,sname,n,lw) - returns a structure with tube of
% length 70 with different wall thickness and diameter
% (by Tim Lueth, VLFL-Lib, 2012-JAN-31)
%
% This experiment should show the flexibility of tube of length 50mm,
% 0.5mm wall and about 2 mm diameter. The procedure is similar to the
% experiment 2011-12-27:2
% Wall [0.5 0.6 0.7 0.8] Inner Diameter [1 2 3 4] n=40;
%
% [VL,FL]=exp_2012_01_31([fname,sname,n,lw])
% === INPUT PARAMETERS ===
% fname: String-Name; default 'TL:MMXII-I-XXXI'; default exp_2012_01_31_1
% sname: String-Name; default 'TL:MMXII-I-XXXI:I'
% n: number of facets; default 40;
% lw: Number of light weight bars, default 0
% === OUTPUT RESULTS ======
% VL: Vertex list of the structure
% FL: Facet list of the structure
%
% EXAMPLE: Generate thin wall structures of different diameters:
% exp_2012_01_31 ('1','TL:MMXII-I-XXXI:I',40)
% exp_2012_01_31 ('2','TL:MMXII-I-XXXI:II',4)
% exp_2012_01_31 ('3','TL:MMXII-I-XXXI:III',40,3)
% exp_2012_01_31 ('4','TL:MMXII-I-XXXI:IV',40,4)
% exp_2012_01_31 ('5','TL:MMXII-I-XXXI:V',40,5)
%
VLFLstarlink(Ro,Ri,bx,f)- returns a structure of several independent objects that can combine an inner and a outer structure
VLFLstarlink(Ro,Ri,bx,f) % VLFLstar(Ro,Ri,bx,by,f) - returns a structure of several independent
% objects that can combine an inner and a outer structure
% (by Tim Lueth, VLFL-Lib, 2010-NOV-03)
%
% This procedure is under development. At a later stage, it should be
% used for realizing light weight strucutres
%
% [VL,FL]=VLFLstar(Ro,Ri,bx,by,f)
% === INPUT PARAMETERS ===
% Ro: Outer Diameter
% Ri: Innerer Diameter
% bx: Thickness in x-direction
% by: Thickness in y-direction
% f: Number of facets
% === OUTPUT RESULTS ======
% VL: Vertex list of the strutures
% FL: Facet list of the strutures
%
% EXAMPLE: Generate 6 bars between 30 mm and 100 mm
% [VL,FL]=VLFLstar (100,30,10,10,6);
% VLFLwriteSTL ('TEST','Tim',VL,FL);
%
exp_2012_01_05(WX,WZ,rl,rb,az,bl,bb,ax)- Generates a full revolving joint including the servo motor sockets
exp_2012_01_05(WX,WZ,rl,rb,az,bl,bb,ax) % exp_2012_01_05(WX,WZ,rl,rb,az,bl,bb,ax) - Generates a full revolving joint including the servo motor sockets
% (by Tim Lueth, VLFL-Lib, 2012-JAN-05 as class: EXPERIMENTS)
%
% Generating a revolute joint including a servo motor socket similar to
% VLFLjointR1(R1H,R1A,R1I,s,R2H,hd,sd) - a revolving joint. After
% 3D-printing the part, several remarks have to be made:
% 1. The number of parameter to descibe construction elements is
% increasing too fast
% 2. The STL design rules have to be more clear
% 3. Torsion become an important topic
% 4. The slot size become an important topic.
% -
% exp_2012_01_16 - slot 0.3, olap=0.012345
% exp_2012_01_17 - slot 0.3, olap=0.111111 (Status of: 2014-12-26)
%
% [VL,FL]=exp_2012_01_05([WX,WZ,rl,rb,az,bl,bb,ax])
% === INPUT PARAMETERS ===
% WX: dimension in x
% WZ: dimension in z
% rl: a nice fnctn
% rb:
% az:
% bl:
% bb:
% ax:
% === OUTPUT RESULTS ======
% VL: Vertex list of the coupling sockets
% FL: Facet list of the coupling sockets
%
% EXAMPLE: Generate an revolute joint 20 x 20 x 30:
% [VL,FL]=exp_2012_01_05 (20,30);
% VLFLplot4(VL,FL,'r');
% VLFLwriteSTL ('Joint2030','by Tim Lueth',VL,FL);
%
exp_2012_01_04- EXPERIMENT that generates a experiment plate with 4 revolute links
exp_2012_01_04 % exp_2012_01_04 - EXPERIMENT that generates a experiment plate with 4
% revolute links
% (by Tim Lueth, VLFL-Lib, 2012-JAN-04 as class: EXPERIMENTS)
%
% [VL,FL]=exp_2012_01_04
% === OUTPUT RESULTS ======
% VL: Vertex list of the object
% FL: Facet list of the object
%
% EXAMPLE: exp_2012_01_04
%
VLFLplot4 (VL,FL,c)- plots a vertex/facet list by fill3 in a figure with 4 Subplots
VLFLplot4 (VL,FL,c) % VLFLplot4 (VL,FL,c) - plots a vertex/facet list by fill3 in a figure with 4 Subplots
% (by Tim Lueth, VLFL-Lib, 2012-JAN-03 as class: VISUALIZATION)
%
% This fnctn plots the VLFL-Object 4 times from different viewpoints. In
% medical it is axis, corronal, saggital. In technical drqwings it is
% Aufsicht, Seitansicht, vorn, Seitansicht links (Status of: 2017-02-08)
%
% See also: VLFLplot, SGplot, TRplot, VLTLplot
%
% VLFLplot4(VL,FL,c)
% === INPUT PARAMETERS ===
% VL: is the vertex list
% FL: is the facet list
% c: is the desired color
%
% EXAMPLE: Experiment for an ellipse:
% [VL,FL]=VLFLellipse (50,10,20,2,20)
% close; VLFLplot4 (VL,FL,'r');
%
VLFLellipse2(H,Rx,Ry,dx,f,sn,h,sb)- returns a vertex list and a facet list for a defined light weight tube geometry
VLFLellipse2(H,Rx,Ry,dx,f,sn,h,sb) % VLFLellipse2(H,Rx,Ry,dx,f,sn,h,sb) - returns a vertex list and a facet
% list for a defined light weight tube geometry
% (by Tim Lueth, VLFL-Lib, 2012-JAN-03)
%
% This procedure directly generates a light weight tube geometry. First
% the top plane is generated, afterwards, the bottom plane, the the
% outside facets and finally the inside facets. The number of lines of
% the enclosing polygon is optional to avoid to many facets. As light
% weight structure the tube consist of a solid top part and sollid bottom
% part with a number of linking bars between. Inside of this procedure
% the linking bar are given as a list. Therefor, if required the bars
% don't have to be symmetric.
% 2010-11-03: First Version of this very powerfull procedure
% 2012-01-03: Version extend to light weight structures by additional
% parameters
%
% [VL,FL]=VLFLellipse2(H,Rx,Ry,dx,f,[sn,h,sb])
% === INPUT PARAMETERS ===
% H: Height; from -Z/2 to +Z/2; center is [0;0;0]
% Rx: Radius in x direction
% Ry: Radius in y direction
% dx: Wall thickness
% f: Number of facets of the polygon, f=4 would be mean a cube shape
% sn: Number of segments of a light weight tube; default is 0
% h: Height of the solids of a light weight tube if desired; default H/8;
% sb: width of the segment bars; default is h
% === OUTPUT RESULTS ======
% VL: Vertex list of the tube
% FL: Facet list of the tube
%
% EXAMPLE: Generate an ellipsoid tube:
% [VL,FL]=VLFLellipse (50,10,10,2,40,3);
% VLFLwriteSTL ('TUBE','with 40 facets as light weight structure,VL,FL);
%
exp_2012_01_03- FINISHED EXPERIMENT for generating a light weight tube using the procedure VLFLellipse2 (2012-01-04)
exp_2012_01_03 % exp_2012_01_03 - FINISHED EXPERIMENT for generating a light weight tube
% using the procedure VLFLellipse2 (2012-01-04)
% (by Tim Lueth, VLFL-Lib, 2012-JAN-03)
%
% This experiment just shows the difference between a full body tube and
% a light weigth tube on the screen. The light weight tube is written
% into a STL file.
%
% [VL,FL]=exp_2012_01_03
% === OUTPUT RESULTS ======
% VL: Vertex list of the coupling sockets
% FL: Facet list of the coupling sockets
%
% EXAMPLE: Just show the use of VLFLellipse
% exp_2012_01_03
%
exp_2012_01_02(rl,rb,az,bl,bb,ax)- FINISHED EXPERIMENT for generating coupling for the FUTABA S3156 Motor consisting of a rod socket and a motor body socket.
exp_2012_01_02(rl,rb,az,bl,bb,ax) % exp_2012_01_02(rl,rb,az,bl,bb,ax) - FINISHED EXPERIMENT for generating
% coupling for the FUTABA S3156 Motor consisting of a rod socket and a
% motor body socket.
% (by Tim Lueth, VLFL-Lib, 2012-JAN-02)
%
% [VL,FL]=exp_2012_01_02([rl,rb,az,bl,bb,ax])
% === INPUT PARAMETERS ===
% rl: length of the rod
% rb: width of the rod
% az: height of the rod above the block in z
% bl: body length of the servo
% bb: body width of the servo
% ax: position of the motor axis in x
% === OUTPUT RESULTS ======
% VL: Vertex list of the coupling sockets
% FL: Facet list of the coupling sockets
%
% EXAMPLE: Generate a coupling for the FUTABA S3156 consisting of two
% parts
% [VL,FL]=exp_2012_01_02 (10,4,12, 32,11,10);
%
%
VLFLmotorRodSocket(ll,bl,az,bb,bh,ml,ch,cb)- returns the vertex/facet list for a rod socket of a servo motor
VLFLmotorRodSocket(ll,bl,az,bb,bh,ml,ch,cb) % VLFLmotorRodSocket(ll,bl,az,bb,bh,ml,ch,cb) - returns the vertex/facet
% list for a rod socket of a servo motor
% (by Tim Lueth, VLFL-Lib, 2012-JAN-02)
%
% Without any parameters this procedure generates a rod socket for a
% servo motor, i.e. the digital servo FUTABA S3156. The x-y plane
% describes the top side of the rod. The socket is below the x-y plane.
% The cover plate of the socket is obove the x-y plane.
%
% [VL,FL]=VLFLmotorRodSocket([ll,bl,az,bb,bh,ml,ch,cb])
% === INPUT PARAMETERS ===
% ll: length of the rod; default is 10 (FUTUBA S3156)
% bl: width of the rob; default is 4 (FUTUBA S3156)
% az: height of the rod top in z; default is 12 (FUTUBA S3156)
% bb: width of the socket walls; default is 1 mm
% bh: height of the socket walls; default is bl/2
% ml: distance between center and start of socket walls; default is bl
% ch: height of the socket cover; default is 1 mm
% cb: width of the socket cover; default is 2*bb
% === OUTPUT RESULTS ======
% VL: Vertex list of the rod socket of a servomotor
% FL: Facet list of the rod socket of a servomotor
%
% EXAMPLE: Generate a rod socket for the FUTUBA S3156 digital servo
% [VL,FL]=VLFLmotorRodSocket (10,4);
% VLFLplot(VL,FL,'m');
% view (0,0), axis equal, xlabel 'X', ylabel 'Y', zlabel 'Z'
%
VLFLmotorBodySocket(sl,sb,ax,bb,bh,wh,wb)- returns the vertex/facet list for a body socket of a servo motor
VLFLmotorBodySocket(sl,sb,ax,bb,bh,wh,wb) % VLFLmotorBodySocket(sl,sb,ax,bb,bh,wh,wb) - returns the vertex/facet
% list for a body socket of a servo motor
% (by Tim Lueth, VLFL-Lib, 2012-JAN-02)
%
% Without any parameters this procedure generates a body socket for a
% servo motor, i.e. the digital servo FUTABA S3156. The x/y-planes
% descibe the lower side of the socket blocks. Therefor the socket is in
% negative direction of z.
%
% [VL,FL]=VLFLmotorBodySocket([sl,sb,ax,bb,bh,wh,wb])
% === INPUT PARAMETERS ===
% sl: length of the motor body in x; default is 32 (FUTUBA S3156)
% sb: width of the motor body in y; default is 11 (FUTUBA S3156)
% ax: position of the motor axis in x; default is 10 (FUTUBA S3156)
% bb: width of the socket blocks; default is 4 mm
% bh: height of the socket blocks; default is 2 mm
% wh: height of the motor body socket housing; default is 10 mm
% wb: width of the motor body sockethousing; default is 1 mm
% === OUTPUT RESULTS ======
% VL: Vertex list of the body socket of a servomotor
% FL: Facet list of the body socket of a servomotor
%
% EXAMPLE: Generate a body socket for the FUTUBA S3156 digital servo
% [VL,FL]=VLFLmotorBodySocket (32,11,10);
% VLFLplot(VL,FL,'m');
% view (0,0), axis equal, xlabel 'X', ylabel 'Y', zlabel 'Z'
%
exp_2011_12_27- EXPERIMENT to create frames from point and directions
exp_2011_12_27 % exp_2011_12_27 - EXPERIMENT to create frames from point and directions
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-27 as class: EXPERIMENTS)
%
% exp_2011_12_27
%
exp_2011_12_27_1(fname,sname,n)-
exp_2011_12_27_1(fname,sname,n)
exp_2011_12_23_2(m,d,o,cl,h)- Experiment Expands from Point List to Polygon to Object
exp_2011_12_23_2(m,d,o,cl,h) % exp_2011_12_23_2(m,d,o,cl,h) - Experiment Expands from Point List to
% Polygon to Object
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-26)
%
% This experiment is a second try to make sure that a polygon can be
% expanded to an solid object
%
% [VL,FL]=exp_2011_12_23_2([m,d,o,cl,h])
% === INPUT PARAMETERS ===
% m: number of points of a circle; default m=8
% d: diameter, default d=3;
% o: orientation: 1=math positive; -1=math negative
% cl: closed polygon
% h: differenz in z
% === OUTPUT RESULTS ======
% VL: Vertex list of object
% FL: Facet list of object
%
% EXAMPLE: Generate an object based as blocking ring
% [VL,FL]=exp_2011_12_23 (16,3,1,false,1);
% view (-40,40); axis equal;
% VLFLwriteSTL ('tmp','by TIM LUETH',VL,FL)
%
VLFLspring(r,h,n,m,dx,dy,l)- returns vertex/facet list for a mechanical spring
VLFLspring(r,h,n,m,dx,dy,l) % VLFLspring(r,h,n,m,dx,dy,l) - returns vertex/facet list for a
% mechanical spring
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-26)
%
% the spring consist of a base plate and a top plate and m helixes that
% are mounted between base plate and top plate
%
% [VL,FL,sx,sy,sz]=VLFLspring([r,h,n,m,dx,dy,l])
% === INPUT PARAMETERS ===
% r: Radius of the spring center; default is 5
% h: Height of the spring (0-max); default is 50
% n: number of full turns; default is h/r
% m: number of springs integrated; default is 3
% dx: width of the spring cable; default is 2
% dy: height of the spring cable; default is dx
% l: height of the base and top plate; default is dy
% === OUTPUT RESULTS ======
% VL: Vertex list of the spring
% FL: Facet list of the spring
% sx: Radius in x-direction
% sy: Radius in y-direction
% sz: Size in z--direction
%
% EXAMPLE: Example for a spring r=10, height h=50; 1 full turn n=1;
% number of helix m=3; dx=2, dy=1;
% [VL,FL,sx,sy,sz]=VLFLspring (5,50,1,3,2,1,1);
% VLFLwriteSTL ('spring_5_50_1_3_2_1','by Tim Lueth',VL,FL);
%
exp_2011_12_26_1(fname)- returns and writes experimental board for different spring types size 10 x 50
exp_2011_12_26_1(fname) % exp_2011_12_26_1(fname) - returns and writes experimental board for
% different spring types size 10 x 50
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-26)
%
% This procedure generates a vertex/facet list and writes an STL file for
% the following Experimental Board:
% Base Plate 50 x 50 grid 12.5 mm including a Identifier Relief showing
% the Date of Experiment 2011-12-26. On the grid there are the following
% objects:
%
% exp_2011_12_26_1([fname])
% === INPUT PARAMETERS ===
% fname: Filename; default is 'exp_2011_12_26_1'
%
% EXAMPLE: Generate the Experimental Board:
% exp_2011_12_26_1('exp_2011_12_26')
%
exp_2011_12_24- Experiment for the extension of a bar
exp_2011_12_24 % exp_2011_12_24 - Experiment for the extension of a bar
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-24 as class: EXPERIMENTS)
%
% [VL,FL]=exp_2011_12_24
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
exp_2011_12_23(m,d,o)- Experiment Expands from Point List to Polygon to Object
exp_2011_12_23(m,d,o) % exp_2011_12_23(m,d,o) - Experiment Expands from Point List to Polygon
% to Object
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-23)
%
% This experiment is a second try to make sure that a polygon can be
% expanded to an solid object
%
% [VL,FL]=exp_2011_12_23([m,d,o])
% === INPUT PARAMETERS ===
% m: number of points of a circle; default m=8
% d: diameter, default d=3;
% o: orientation: 1=math positive; -1=math negative
% === OUTPUT RESULTS ======
% VL: Vertex list of object
% FL: Facet list of object
%
% EXAMPLE: Generate an object based on a octaeder
% [VL,FL]=exp_2011_12_23 (8,3,1);
% view (-40,40); axis equal;
% VLFLwriteSTL ('tmp','by TIM LUETH',VL,FL)
%
VLFLexpboard(text,dx,dy,dz,nx,ny)- returns vertex/facet list of a test board with textural description
VLFLexpboard(text,dx,dy,dz,nx,ny) % VLFLexpboard(text,dx,dy,dz,nx,ny) - returns vertex/facet list of a test
% board with textural description
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-18)
%
% The experimental bord is designed that the whole space is free for the
% experimental bodys. Therefor, the plate is from -dz to 0. Also the
% textural description is showing the y-axis and is outside of the dx *
% dy area on a frieze/relief.
% 2011-12-24: Amendment of variable overlap ol and nx and ny as parameter
%
% [VL,FL]=VLFLexpboard([text,dx,dy,dz,nx,ny])
% === INPUT PARAMETERS ===
% text:
% dx: size of the board in x [0..x]; default dx=50
% dy: size of the board in y [0..y]; default dy=dx
% dz: size of the board in z [0..-z]; default z=2; minimum is 1
% nx: distance between bars in x; default ist 0
% ny: distance between bars in y; default ist nx
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
% EXAMPLE: Generate an ground plate of an experimental body of size
% 50x50x1mm
% [VL,FL]=VLFLexpboard('TL:MMXI-XII-XVIII:I',50,50,1);
% VLFLwriteSTL ('TEST', 'by Tim C Lueth',VL,FL);
% close; VLFLplot (VL,FL,'r')
%
exp_2011_12_18- Experiment generates a base plate and 4 revolute joints (hinge) with 2, 1, 0.5, 0.3 slot distance
exp_2011_12_18 % exp_2011_12_18 - Experiment generates a base plate and 4 revolute
% joints (hinge) with 2, 1, 0.5, 0.3 slot distance
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-18)
%
% [VL,FL]=exp_2011_12_18
% === OUTPUT RESULTS ======
% VL: Vertex list of the object
% FL: Facet list of the object
%
% EXAMPLE: Generate the file: exp_2011_12_18.STL
% close;
% exp_2011_12_18;
%
VLFLtext(text,dt,t,sx,sy,sz)- returns vertex/facet list for a text string
VLFLtext(text,dt,t,sx,sy,sz) % VLFLtext(text,dt,t,sx,sy,sz) - returns vertex/facet list for a text string
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-17 as class: TEXT PROCEDURES)
%
% Works only with roman numbers and TL: For more complex text and latex
% strings use VLFLtextimage which works in a different style (Status of:
% 2017-03-15)
%
% See also: VLFLchar, VLFLtextimage, VLFLtextattachVLUL
%
% [VL,FL,dx,dy,dz]=VLFLtext(text,[dt,t,sx,sy,sz])
% === INPUT PARAMETERS ===
% text: String consisting of characters 'TL:-MXVI'
% dt: Distance between two chars; default is 0.5
% t: Thickness of the base plate [0..-t]; default is 1
% sx: Size in x; default is 0, i.e. no scaling
% sy: Size in y; default is 0, i.e. no scaling
% sz: Size in z; default is 0, i.e. no scaling
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet List
% dx: Size in x [0..x]
% dy: Size in y [0..y]
% dz: Size in x [0..z]
%
% EXAMPLE: Generate todays date as plate:
% [VL,FL,d]=VLFLtext('TL-MMXI-XII-XVII');
% VLFLwriteSTL ('exp_2011_12_17', 'by Tim C Lueth',VL,FL);
%
exp_2011_12_17(text)- simply generates a test file for a generated date signature string
exp_2011_12_17(text) % exp_2011_12_17(text) - simply generates a test file for a generated
% date signature string
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-17)
%
% Generates an STL file 'exp_2011_12_17.STL' that contains a string.
% The object size is 50 x 10 x 30.
%
% [VL,FL,d]=exp_2011_12_17(text)
% === INPUT PARAMETERS ===
% text: A string consisting of the characters 'TL:-MXVI'
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
% d: length of the structure
%
% EXAMPLE: Show the current date:
% close; [VL,FL,d]=exp_2011_12_17 ('TL:MMXI-XII-XVII');
%
work- changes working directory and opens Filemaker
work % work - changes working directory and opens Filemaker
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-12 as class: AUXILIARY PROCEDURES)
%
% This is a simple procedure for Tim Lueth
% Set MNPATH to desktopdir
% Changes into VLFL-Lib
% Opens Documentation Datatbase
% displays the last 10 changed .m files (Status of: 2015-12-07)
%
% work
%
% EXAMPLE: simply type:
% work
%
exp_2011_12_11(fname,R1H,R1A,R1I,s,R2H,hd,sd)- returns vertices/facets of a revolving joint
exp_2011_12_11(fname,R1H,R1A,R1I,s,R2H,hd,sd) % exp_2011_12_11(fname,R1H,R1A,R1I,s,R2H,hd,sd) - returns vertices/facets
% of a revolving joint
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-11)
%
% [VL,FL]=exp_2011_12_11([fname,R1H,R1A,R1I,s,R2H,hd,sd])
% === INPUT PARAMETERS ===
% fname: Optional Filename; default is: 'exp_2011_12_11'
% R1H: Height of the overall link
% R1A: Outer Diameter of the inner axis
% R1I: Inner Diameter of the inner axis
% s: distance between inner and outer axis
% R2H: Height of the outer axis; Default is R1H/3
% hd: Height of the block; default is 1
% sd: distance between block and outer axis; default is s
% === OUTPUT RESULTS ======
% VL: Vertex list of object
% FL: Facet list of object
%
% EXAMPLE: Generate a link with Length 30, Inner axis 1 mm, hollow shaft
% 0.5mm, distance between axis 0.5mm
% close; [VL,FL]=exp_2011_12_11 ('exp_2011_12_11-f',30,1,0.5,0.5);
%
VLhelix(R,d,w2,w1,err)- generates a vertex list for a specified helix
VLhelix(R,d,w2,w1,err) % VLhelix(R,d,w2,w1,err) - generates a vertex list for a specified helix
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-09 as class: ANALYZING PROCEDURES)
%
% returns a PL spiral or a VL helix depending on d=[] or d=z
% Name changed from PLhelix to VLhelix in Aug, 2015
% PLhelix will be changed to PLspiral for [nx2] (Status of: 2015-08-19)
%
% [VL,n]=VLhelix(R,[d,w2,w1,err])
% === INPUT PARAMETERS ===
% R: Radius (centered) of the helix
% d: Height (centered) of the helix
% w2: Optional turn angle, default is 2pi
% w1: Optional starting angle, default is 0
% err: Optional maximum geometry error, default is 0.05
% === OUTPUT RESULTS ======
% VL: Vertex list [nx3] of the helix in z-direction
% n: size(VL,1)
%
% EXAMPLE: VLhelix (10,40,8*pi)
%
exp_2011_12_09(fname,R,d,w2,w1)- is used to calculate a spring or a structure from a polygon
exp_2011_12_09(fname,R,d,w2,w1) % exp_2011_12_09(fname,R,d,w2,w1) - is used to calculate a spring or a
% structure from a polygon
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-09)
%
% There is still a problem with T2P at 90 degree
%
% [VL,FL]=exp_2011_12_09([fname,R,d,w2,w1])
% === INPUT PARAMETERS ===
% fname: optional filename; default is 'exp_2011_12_09'
% R: Radius of the spring; default is 10
% d: Height of the spring; default is 40
% w2: Angle of rotation, default is 2 pi, i.e. 360 DEG
% w1:
% === OUTPUT RESULTS ======
% VL: Vertex list of the experiment result
% FL: Facet list of the experiment result
%
% EXAMPLE: Helix with diameter 10, hight 40 and 4 turns
% [VL,FL]=exp_2011_12_09 ('test',10,40,8*pi-0.1,-0.01);
%
PLhelix(R,d,w2,w1,err)- generates a list of points for a specified helix/spiral
PLhelix(R,d,w2,w1,err) % PLhelix(R,d,w2,w1,err) - generates a list of points for a specified helix/spiral
% (by Tim Lueth, VLFL-Lib, 2011-DEZ-09 as class: ANALYZING PROCEDURES)
%
% returns a PL spiral or a VL helix depending on d=[] or d=z
% (Status of: 2017-01-05)
%
% See also: PLcircle, PLcircseg, PLevolvente, PLgear, PLkidney, PLrand,
% PLspiral, PLsquare, PLstar
%
% [PL,n]=PLhelix(R,[d,w2,w1,err])
% === INPUT PARAMETERS ===
% R: Radius (centered) of the helix
% d: Height (centered) of the helix
% w2: Optional turn angle, default is 2pi
% w1: Optional starting angle, default is 0
% err: Optional maximum geometry error, default is 0.05
% === OUTPUT RESULTS ======
% PL: List of points of the defined helix in z-direction
% n: size(PL,1)
%
% EXAMPLE: PL=PLhelix(10,40)'; VLplot (PL)
%
navScreen- opens a figure with defined number and draws a typical 4 subscreen navigation scren
navScreen % navScreen - opens a figure with defined number and draws a typical 4 subscreen navigation scren
% (by Tim Lueth, NAV-Lib, 2011-JUN-14 as class: USER INTERFACE)
%
% =======================================================================
% OBSOLETE (2017-03-20) - USE FAMILY 'VMplot' INSTEAD
% =======================================================================
%
% navScreen
%
exp_2010_11_26(fname)- Experimental cube 50x50x50 containing revolute DoF with different fittings
exp_2010_11_26(fname) % exp_2010_11_26(fname) - Experimental cube 50x50x50 containing revolute
% DoF with different fittings
% (by Tim Lueth, EXPERIMENT, 2010-NOV-26)
%
% This procedure is time consuming, takes about a minute calculation time.
% The cube contains stator and rotor elements. For each stator we have
% one rotor which is printed directly on the stator and a second rotor to
% be moved on the stator after printing, which is printed on a thinner
% stator above. The thicker real stator has a radius of R-1.5mm, the
% thinner stator/wire has a radius of R=1.0 mm. The length of the
% directly printed rotors are scaled to get a feeling for the effect of
% 'glued' rotors depending on the length.
%
% The Radius R of the stator is R=1,5 mm
% The Accuracy th is (0,4mm) for the polygon surface error
% The fittings are:
% sd=0,05 (radius difference/fitting)
% sd=0,10 (radius difference)
% sd=0,15 (radius difference)
% sd=0,20 (radius difference)
% sd=0,25 (radius difference)
% sd=0,30 (radius difference)
%
% [VL,FL]=exp_2010_11_26([fname])
% === INPUT PARAMETERS ===
% fname: Optional File Name, Default is 'exp_2010_11_26'
% === OUTPUT RESULTS ======
% VL: Vertex list of the test body
% FL: Facet list of the test body
%
% EXAMPLE: Generate the test body
% [VL,FL]=exp_2010_11_26 ('RevoluteCube 2');
%
VLFLweave(x,y,n,m,h,b,s,f)- returns the vertex list XVL and facet list XFL of a weaved rectangle
VLFLweave(x,y,n,m,h,b,s,f) % VLFLweave(x,y,n,m,h,b,s,f) - returns the vertex list XVL and facet list
% XFL of a weaved rectangle
% (by Tim Lueth, VLFL-Lib, 2010-NOV-21 as class: SYNTHESIZING PROCEDURES)
%
% [XVL,XFL]=VLFLweave(x,y,n,m,h,b,s,f)
% === INPUT PARAMETERS ===
% x: Size of the Tissue in x-direction (-x/2 .. x/2)
% y: Size of the Tissue in y-direction (-y/2 .. y/2)
% n: Number if notches
% m: Grid Ratio (1)
% h: Thickness in y-direction (VLFLyarn)
% b: Thickness in z-direction (VLFLyarn)
% s: Slot distance (VLFLyarn)
% f: Thickness of the enclosing frame if f>0
% === OUTPUT RESULTS ======
% XVL: Vertex list of a textile-tissue structure as a combination of
% crossed wire-yarns
% XFL: Facet list of a textile-tissue structure as a combination of
% crossed wire-yarns
%
% EXAMPLE: Generate a weaved plane (100 x 100) with 20 yarns:
% [VL,FL]=VLFLweave (100,100,20,1,1,1,0,1);
% VLFLwriteSTL ('YARN','(c) by Tim C. Lueth',VL,FL);
%
exp_2010_11_21(fname)- generates a cube 50 mm with weaved surfaces on all 6 sides (takes several minutes)
exp_2010_11_21(fname) % exp_2010_11_21(fname) - generates a cube 50 mm with weaved surfaces on
% all 6 sides (takes several minutes)
% (by Tim Lueth, EXPERIMENT, 2010-NOV-21)
%
% Alle 6 sides are processed in a different way with different
% parameters. The experiment is a good example to see how to use
% VLFLweave.
% The output is written into the file 'exp_2010_11_21.STL' former
% 'Weavecube 3'
%
% [VL,FL]=exp_2010_11_21([fname])
% === INPUT PARAMETERS ===
% fname: Filename, default is 'exp_2010_11_21.STL'
% === OUTPUT RESULTS ======
% VL: Vertex list of the weaved cube
% FL: Facet list of the weaved cube
%
VLFLyarn(l,n,ld,b,h,s,u)- calculates vertex list and facet list for a wire-yarn Example: [[VL,FL]=VLFLyarn (l,n,ld,b,h,s,u) takes over length l, number of notches ld length of element (at least b for tissue) b, width, h height, s for slotdistance u for direction of notches
VLFLyarn(l,n,ld,b,h,s,u) % VLFLyarn(l,n,ld,b,h,s,u) - calculates vertex list and facet list for a
% wire-yarn
% Example: [[VL,FL]=VLFLyarn (l,n,ld,b,h,s,u) takes over length l, number
% of notches ld length of element (at least b for tissue) b, width, h
% height, s for slotdistance u for direction of notches
% (by Tim Lueth, VLFL-Lib, 2010-NOV-20 as class: SYNTHESIZING PROCEDURES)
%
% This procedure calculates a 'bent wire style object' that is called
% yarn. The procedure uses mainly VLFLbar2P. It is also a good example
% how to design bars, and later to remove the planes at the beginning and
% the end for concatenating different segments. (Status of: 2012-05-05)
%
% [VL,FL]=VLFLyarn(l,n,ld,b,h,s,u)
% === INPUT PARAMETERS ===
% l: length of the yarn in x-direction
% n: number of notches (1 is up, 2 us up and down, if u=1)
% ld: lenght of the notches (half at the begining and end)
% b: Thickness of the wire-yarn in z-Axis
% h: Thickness of the wire-yarn in y-Axis
% s: Additional Slot Distance beside h/2 (required depending on the
% crossing wires) can be negative
% u: direction of notches (1 starts in +y-direction, -1 starts in -y
% direction)
% === OUTPUT RESULTS ======
% VL: Vertex list of the wire-yarn
% FL: Facet list of the wire-yarn
%
% EXAMPLE: Simple wire-yarn:
% [VL,FL]=VLFLyarn (100,5,4,1,1,1,-1);
% VLFLwriteSTL ('YARN','(c) by Tim C. Lueth',VL,FL);
%
VLFLcylinder(Z,R,f,o)- calculates vertex list and facet list for a cylinder
VLFLcylinder(Z,R,f,o) % VLFLcylinder(Z,R,f,o) - calculates vertex list and facet list for a
% cylinder
% (by Tim Lueth, VLFL-Lib, 2010-NOV-20 as class: SYNTHESIZING PROCEDURES)
%
% [VL,FL]=VLFLcylinder (Z, R, f, o) generates an sweept polyder of height
% Z with radius R and f edges. With o==1 or o==-1 the normal vectors are
% outside (1) or inside (-1).
% This procedure looks similar to VLFLellipse, but seems to be an earlier
% version, and calculates a solid object. In case of a hollow cylinder,
% it is not possible to print it in SLS. So, there is a need for a CSG
% subtraction. (Status of: 2012-05-05)
%
% [VL,FL]=VLFLcylinder(Z,R,f,o)
% === INPUT PARAMETERS ===
% Z: Height of the cylinder
% R: Radius of the cylinder
% f: Number of facets of the cylinder
% o: direction (1=outward, -1=inwards) of the facets
% === OUTPUT RESULTS ======
% VL: Vertex list of the cylinder
% FL: Facet list of the cylinder
%
% EXAMPLE: Calucate a hollow cylinder (cannot printed in SLS)
% [V1,F1]=VLFLcylinder (4,1,4,1); [V2,F2]=VLFLcylinder (4-2,1-2,4,-1);
% [VL,FL]=VLFLcat(V1,F1,V2,F2);
% VLFLwritestl (VL,FL,'CYL', 'a cylinder');
% VLFLplot (VL,FL,'g')
%
exp_2010_11_20- generates a smooth link between two rigid bodies
exp_2010_11_20 % exp_2010_11_20 - generates a smooth link between two rigid bodies
% (by Tim Lueth, EXPERIMENT, 2010-NOV-20)
%
% This is WORK IN PROGRESS and shows a result on the screen an a result
% in a file.
% CYL a file of the linking segment
% TISSUE the combined rigid and linked body
%
% exp_2010_11_20
%
exp_2010_11_16- NOT FINISHED Experiment to find all crossing points of two given solids
exp_2010_11_16 % exp_2010_11_16 - NOT FINISHED Experiment to find all crossing points of
% two given solids
% (by Tim Lueth, VLFL-Lib, 2010-NOV-16 as class: EXPERIMENTS)
%
% exp_2010_11_06 is an experiment that calculates the crossing points of
% two solids given by a vertex list and facets list each. It writes three
% files on disc.
% V1.STL for Body 1
% V2.STL for Body 2
% XVL.STL for the concatenated body
% The procedures uses VLFLadd, but the finally written procedure is
% VLFLcross! (Status of: 2012-11-04)
%
% exp_2010_11_16
%
exp_2010_11_15- Experiment that shows the crossing problem of two solids given by two Vertex lists / Facet lists.
exp_2010_11_15 % exp_2010_11_15 - Experiment that shows the crossing problem of two
% solids given by two Vertex lists / Facet lists.
% (by Tim Lueth, VLFL-Lib, 2010-NOV-15 as class: EXPERIMENTS)
%
% [CVL,CFL]=exp_2010_11_15
% === OUTPUT RESULTS ======
% CVL: Crossing certex list
% CFL: Crossing facet list
%
nofrd(r,d,w)- returns the minimum number of edges to guarante a slot distance between a peg and a hole
nofrd(r,d,w) % nofrd(r,d,w) - returns the minimum number of edges to guarante a slot distance between a peg and a hole
% (by Tim Lueth, VLFL-Lib, 2010-NOV-13 as class: ANALYTICAL GEOMETRY)
%
% For rapid prototyping it makes no sense to print a cylinder as sweeped
% polygon with hundreds of edges. For a peg in hole problem there must be
% a slot distance between peg and hole. The reduced radius of the hole by
% the direct line between to edges of the polygon is Rh(1-cos(pi/n). The
% radius of the peg is never increased only decreased. To guarantee a
% slot distance the correct formula is n>m/acos(1-slot/Rh). To make sure
% that only half of the slot is used, we recommend to use it with slot
% distance/2. Always the larger Radius, i.e. the hole radius has to be
% used in this formula.
% Currently the minimum slot size should be known as 0.3 for an RP
% machine. The minimum resolution is 0.1, Therefor with d=0.05 the number
% of polygons is perfect for the machine. The minimum particle size is
% 0.5, so for a resolution of one particle for the diameter, the radius
% requires a resolution of 0.025 (Status of: 2017-01-03)
%
% See also: nofrd, dofn, sofrd, phiofsr
%
% n=nofrd(r,[d,w])
% === INPUT PARAMETERS ===
% r: radius of a circle, cylinder etc.
% d: slot size or maximum roughness; default is 0.025
% w: optional angle; default is 2*pi
% === OUTPUT RESULTS ======
% n: minimum number of edges for a given radius and error
%
% EXAMPLE: Generating a Cylinder with a maximum error of 0.01 between
% thereal radius and the smallest radius between the polygons
% [NVL,NFL]=VLFLcylinder (Z, R, nofrd(R, 0.01 ), 1);
%
exp_2010_11_05(b,fname)- generates a 50x50x50 mm cube grid containing 20 different bending bars
exp_2010_11_05(b,fname) % exp_2010_11_05(b,fname) - generates a 50x50x50 mm cube grid containing
% 20 different bending bars
% (by Tim Lueth, EXPERIMENT, 2010-NOV-05)
%
% The object is a 50x50x50 mm cube grid containing 20 different bending
% bars. Finally the object is plotted and written in an STL file using
% VLFLwritestl ('BBCube10','Tim C. Lueth',VL,FL);
% The Object has been uploaded to www.shapeways.com in Nov. 2011
%
% [VL,FL]=exp_2010_11_05([b,fname])
% === INPUT PARAMETERS ===
% b: Optional thickness of the box, default is 2
% fname: Optional Filename, default is 'BBCube10’
% === OUTPUT RESULTS ======
% VL: Vertex list of the experimental object
% FL: Facet list of the experimental object
%
VLFLellipse1(Z,Rx,Ry,dx,f)- returns a vertex list and a facet list for a defined tube geometry
VLFLellipse1(Z,Rx,Ry,dx,f) % VLFLellipse1(Z,Rx,Ry,dx,f) - returns a vertex list and a facet list for
% a defined tube geometry
% (by Tim Lueth, VLFL-Lib, 2010-NOV-03)
%
% This procedure directly generates a tube geometry. First the top plane
% is generated, afterwards, the bottom plane, the the outside facets and
% finally the inside facets. The number of lines of the enclosing polygon
% is optional to avoid to many facets.
%
% [VL,FL]=VLFLellipse1(Z,Rx,Ry,dx,f)
% === INPUT PARAMETERS ===
% Z: Height; from -Z/2 to +Z/2; center is [0;0;0]
% Rx: Radius in x direction
% Ry: Radius in y direction
% dx: Wall thickness
% f: Number of facets of the polygon, f=4 would be mean a cube shape
% === OUTPUT RESULTS ======
% VL: Vertex list of the tube
% FL: Facet list of the tube
%
% EXAMPLE: Generate an ellipsoid tube:
% [VL,FL]=VLFLellipse (100,5,10,1,40,0); VLFLwriteSTL ('TUBE','with 40
% facets',VL,FL);
%
VLFLstar(Ro,Ri,bx,by,f)- returns a structure of several independent objects that can combine an inner and a outer structure
VLFLstar(Ro,Ri,bx,by,f) % VLFLstar(Ro,Ri,bx,by,f) - returns a structure of several independent
% objects that can combine an inner and a outer structure
% (by Tim Lueth, VLFL-Lib, 2010-NOV-03)
%
% This procedure is under development. At a later stage, it should be
% used for realizing light weight strucutres
%
% [VL,FL]=VLFLstar(Ro,Ri,bx,by,f)
% === INPUT PARAMETERS ===
% Ro: Outer Diameter
% Ri: Innerer Diameter
% bx: Thickness in x-direction
% by: Thickness in y-direction
% f: Number of facets
% === OUTPUT RESULTS ======
% VL: Vertex list of the strutures
% FL: Facet list of the strutures
%
% EXAMPLE: Generate 6 bars between 30 mm and 100 mm
% [VL,FL]=VLFLstar (100,30,10,10,6);
% VLFLwriteSTL ('TEST','Tim',VL,FL);
%
VLFLwriteSTL (VL,FL)- writes a STL object given by vertex list and facet list in a STL-file
VLFLwriteSTL (VL,FL) % VLFLwriteSTL (VL,FL) - writes a STL object given by vertex list and
% facet list in a STL-file
% (by Tim Lueth, GTK10-Lib, 2010-OKT-17 as class: FILE HANDLING)
%
% Tim C. Lueth, Franz Irlinger: "Berechnete Erzeugung von
% dreidimensionalen Oberflächenmodellen im STL-Format aus der
% Beschreibung planarer Mechanismen für die Generative Fertigung durch
% Selektives-Lasersintern [Computational 3D Surface Generation of Planar
% Mechanismus using STL File Format for Generative Manufacturing by
% Selective Laser Sintering]", angenommener Beitrag im Konferenzband 10.
% Kolloquium Getriebetechnik, TU Ilmenau, Sep. 11-13, 2013, pp 1-18.
% (Status of: 2016-12-27)
%
% See also: SGreadSTL, SGwriteSTL, VLFLreadSTL, STLAsctoBin
%
% VLFLwriteSTL(VL,FL)
% === INPUT PARAMETERS ===
% VL: is the vertex list
% FL: is the facet list
%
VLFLplot (VL,FL)- plots a surface geometry
VLFLplot (VL,FL) % VLFLplot (VL,FL) - plots a surface geometry
% (by Tim Lueth, VLFL-Lib, 2010-OKT-17 as class: VISUALIZATION)
%
% Tim C. Lueth, Franz Irlinger: "Berechnete Erzeugung von
% dreidimensionalen Oberflächenmodellen im STL-Format aus der
% Beschreibung planarer Mechanismen für die Generative Fertigung durch
% Selektives-Lasersintern [Computational 3D Surface Generation of Planar
% Mechanismus using STL File Format for Generative Manufacturing by
% Selective Laser Sintering]", angenommener Beitrag im Konferenzband 10.
% Kolloquium Getriebetechnik, TU Ilmenau, Sep. 11-13, 2013, pp 1-18.
% (Status of: 2016-12-28)
%
% See also: VLFLsnapfit, VLFLshaft, VLFLhollowsnapaxle, VLFLcat,
% TofDPhiH, VLtransT, VLFLspacer, VLFLbolt, VLFLlinkage, VLFLofPLz,
% VLFLwriteSTL, VLFLofPLELz
%
% VLFLplot(VL,FL)
% === INPUT PARAMETERS ===
% VL: Vertex List
% FL: Facet Liste
%
VLFLplot(VL,FL,c,fe,nl)- plots a vertexlist and facet list by fill3 in a figure
VLFLplot(VL,FL,c,fe,nl) % VLFLplot(VL,FL,c,fe,nl) - plots a vertexlist and facet list by fill3 in a figure
% (by Tim Lueth, VLFL-Lib, 2010-OKT-17 as class: VISUALIZATION)
%
% See also: VLFLplot, SGplot, TRplot, VLTLplot, VLFLplot4
%
% h=VLFLplot(VL,FL,[c,fe,nl])
% === INPUT PARAMETERS ===
% VL: is the vertex list
% FL: is the facet list
% c: is the desired color
% fe: Thickness of feature edges
% nl: length of normal vector; default is 0;
% === OUTPUT RESULTS ======
% h: handle
%
VLFLbox(X,Y,Z,o)- OBSOLETE PROCEDURE calculates vertex list and facet list for a cuboid
VLFLbox(X,Y,Z,o) % VLFLbox(X,Y,Z,o) - calculates vertex list and facet list for a cuboid
% (by Tim Lueth, VLFL-Lib, 2010-OKT-17 as class: OBSOLETE PROCEDURES)
%
% OBSOLETE PROCEDURE REPLACED BY NEW CONCEPTS: VLFLcreateblock, FLswap,
% etc.
% It generates the vertex list and facet list for a cuboid of length X
% width Y and height Z.
% With o==1 or o==-1 the normal vectors are outside (1) or inside (-1).
% It is also possible to generate a cuboid with VLFLcylinder.
%
% [VL,FL]=VLFLbox(X,Y,Z,o)
% === INPUT PARAMETERS ===
% X: Length in X (centered around origin)
% Y: Length in Y (centered around origin)
% Z: Length in Z (centered around origin)
% o: 1 ~ Facets direct outwards, -1 ~ facet directs inwards
% === OUTPUT RESULTS ======
% VL: Vertex list
% FL: Facet list
%
VLFLwriteSTL (VL,FL,FNAME,ONAME)- writes a STL object given by vertex list and facet list in a STL-file
VLFLwriteSTL (VL,FL,FNAME,ONAME) % VLFLwriteSTL (VL,FL,FNAME,ONAME) - writes a STL object given by vertex list and facet list in a STL-file
% (by Tim Lueth, VLFL-Lib, 2010-OKT-16 as class: FILE HANDLING)
%
% Most important procedure to write an STL object given by vertex list
% and facet list as STL-file (Status of: 2017-02-08)
%
% See also: SGreadSTL, SGwriteSTL, VLFLreadSTL, STLAsctoBin
%
% VLFLwriteSTL(VL,FL,[FNAME,ONAME])
% === INPUT PARAMETERS ===
% VL: is the vertex list
% FL: is the facet list
% FNAME: name of the desired file on Desktop
% ONAME: name of the STL object
%
% EXAMPLE: Writing vertex list and facet list as STL:
% VLFLwriteSTL (VL,FL,'test.STL','by Tim Lueth')
%
center4P(p1,p2,p3,p4)- Center and diameter of a sphere given by 4 points
center4P(p1,p2,p3,p4) % center4P(p1,p2,p3,p4) - Center and diameter of a sphere given by 4 points
% (by Tim Lueth, HT-Lib, 2010-SEP-12 as class: ANALYTICAL GEOMETRY)
%
% [p,r,w] = center4P(p1,p2,p3,p4) returns center p and radius r of a
% sphere given by 4 surface points. w ist the angle between the two
% straight lines which are the crossing lines of two intesection planes.
% If w is about zero or w is about pi, then the result is not a defined
% point but an straight line, i.d. there are infinity solutions. In this
% there is a symmetrie between the surface points. (Status of: 2017-02-01)
%
% See also: center3P, tangente, tangenteRP, centerVL, centerPL
%
% [px,rx]=center4P(p1,p2,p3,p4)
% === INPUT PARAMETERS ===
% p1: Point 1 of the sphere
% p2: Point 2 of the sphere
% p3: Point 3 of the sphere
% p4: Point 4 of the sphere
% === OUTPUT RESULTS ======
% px: position of the sphere’s origin
% rx: radius of the sphere
%
% EXAMPLE: P=VLnorm(rand(4,3)-0.5)*8; close all;
% center4P(P(1,:),P(2,:),P(3,:),P(4,:))
%
distT(T,p)- returns orthogonal vector and normal vector to T-plane
distT(T,p) % distT(T,p) - returns orthogonal vector and normal vector to T-plane
% (by Tim Lueth, HT-Lib, 2010-SEP-10 as class: ANALYTICAL GEOMETRY)
%
% Shortest distance to x/y-plane is always the z value.
% The normal vector is simply [0 0 z].
% The position on the straight line is p-o
% The position on the plane is p-n
% The projection line is from p-n to p-n-o (Status of: 2015-01-27)
%
% [o,n]=distT(T,p)
% === INPUT PARAMETERS ===
% T: 4x4 Homogenous Transformation Matrix
% p: 1x3 or 3x1 vector
% === OUTPUT RESULTS ======
% o: orthogonal vector: 1x3
% n: normal vector: 1x3
%
center3Pn(p1,p2,p3)- Center line of a cylinder given by 3 points
center3Pn(p1,p2,p3) % center3Pn(p1,p2,p3) - Center line of a cylinder given by 3 points
% (by Tim Lueth, HT-Lib, 2010-SEP-10 as class: ANALYTICAL GEOMETRY)
%
% [T,r] = center3P(p1,p2,p3) returns a straight line that is the center
% of alle 3 points, i.e. each point of the line has the same distance to
% all threes point. The Origin of T is the point with the minimum
% distance to p1, p2, p3. r is the distance to all points.
% Changes Algorithm on 2017-06-25 (Status of: 2017-06-25)
%
% See also: center3P, center4P, tangente, tangenteRP, centerVL, centerPL,
% cross4P
%
% [T,r]=center3Pn(p1,p2,p3)
% === INPUT PARAMETERS ===
% p1: Point 1 of the circle or cylinder, or Vertex List
% p2: Point 2 of the circle or cylinder
% p3: Point 3 of the circle or cylinder
% === OUTPUT RESULTS ======
% T: Matrix of a cylinder center line
% r: Radius of a cylinder
%
tlplot (T,c,l)- plots a line given as HT matrix using t+k*ez
tlplot (T,c,l) % tlplot (T,c,l) - plots a line given as HT matrix using t+k*ez
% (by Tim Lueth, HT-Lib, 2010-SEP-04 as class: VISUALIZATION)
%
% See also: pplot, lplot, tfplot, slplot, plotTP, plotL, plotT, T2plot
%
% tlplot(T,[c,l])
% === INPUT PARAMETERS ===
% T: Transformation matrix
% c: color
% l: length of line
%
crossL(T)- returns the crossing points of a stright line with the main planes where z=0, x=0 or y=0
crossL(T) % crossL(T) - returns the crossing points of a stright line with the main
% planes where z=0, x=0 or y=0
% (by Tim Lueth, ESRD-Lib, 2010-SEP-04)
%
% PL=crossL (T) returns a 3x3 matrix PL=[px py pz]. px ist the crossing
% point of the ez vector with the y/z-plane, py is the crossing point of
% the ez vector with the x/z plane and ez is the crossing point
% of the ez vector to the x/yplane. All three points are points of the
% straight line. (Status of: 2014-12-26)
%
% PL=crossL(T)
% === INPUT PARAMETERS ===
% T: HT-Matrix of a straight line
% === OUTPUT RESULTS ======
% PL: List of 3 Points [px py pz] of the line thorugh the main planes
%
% EXAMPLE: Show the crossing points of line an main planes
% crossL(T2P([3 0 5],[1 1 1]))
%
cross2L(TG1,TG2)- returns the crossing point of two straight lines
cross2L(TG1,TG2) % cross2L(TG1,TG2) - returns the crossing point of two straight lines
% (by Tim Lueth, HT-Lib, 2010-SEP-04)
%
% [p,E] = cross2L (TG1, TG2) returns the crossing point p by solving the
% linear equation using the gauss-elemination problem (rref). If E(1,3)
% or (E(2,3) are zero, then both lines are identical. (Status of:
% 2014-12-26)
%
% [p,d]=cross2L(TG1,TG2)
% === INPUT PARAMETERS ===
% TG1: HT-Matrix of line 1
% TG2: HT-Matrix of line 2
% === OUTPUT RESULTS ======
% p: crossing point/minimal distance point (1x3) of the two lines
% d: minimal distance between the two line if they don’t cross
%
% EXAMPLE: cross2L(T2P([0 0 0],[1 0 0]),T2P([2 0 0],[2 2 1])), show
%
cross2T(T1,T2)- returns 3 crossing points of plane T1 with the plane T2
cross2T(T1,T2) % cross2T(T1,T2) - returns 3 crossing points of plane T1 with the plane T2
% (by Tim Lueth, HT-Lib, 2010-AUG-24 as class: ANALYTICAL GEOMETRY)
%
% PL=cross2T (T1,T2) returns a 3x3 matrix PL=[px py pz]. px ist the
% crossing point of the ex vector of T2 with the x/y-plane of T1, py is
% the crossing point of the ey vector of T2 with the x/y plane of T1 and
% ez is the crossing point of the ez vector of T2 to the x/y plane of T1.
% The straigt line through px and py is the crossing line of the plane.
% If one ore more axis are parallel to the plane, the resulting
% corresponding vector is [NaN;NaN;NaN]
% (Status of: 2012-11-24)
%
% PL=cross2T(T1,T2)
% === INPUT PARAMETERS ===
% T1: HT matrix 1 (plane), that describes a plane by an ez-Vector and a
% position p
% T2: HT matrix 2 (plane), at describes a plane by an ez-Vector and a
% position p
% === OUTPUT RESULTS ======
% PL: is a list of 3 points PL=[px py pz] describing the crossing points
% of ex, ey, and ez vectors with the x/y plane (z=0).
%
crossT(TE)- returns 3 crossing points of a plane TE with the x/y-plane (z=0)
crossT(TE) % crossT(TE) - returns 3 crossing points of a plane TE with the x/y-plane
% (z=0)
% (by Tim Lueth, HT-Lib, 2010-AUG-24)
%
% PL=crossT (TE) returns a 3x3 matrix PL=[px py pz]. px ist the crossing
% point of the ex vector with the x/y-plane, py is the crossing point of
% the ey vector with the x/y plane and ez is the crossing point
% of the ez vector to the x/yplane. The straigt line through px and py is
% the crossing line of the plane. If one ore more axis are parallel to
% the plane, the resulting corresponding vector is [NaN;NaN;NaN]
% (Status of: 2012-11-24)
%
% PL=crossT(TE)
% === INPUT PARAMETERS ===
% TE: is the HT matrix that describes a plane by an ez-Vector and a
% position p
% === OUTPUT RESULTS ======
% PL: is a list of 3 points PL=[px py pz] describing the crossing points
% of ex, ey, and ez vectors with the x/y plane (z=0).
%
% EXAMPLE: Test different plane decriptions (t=O, ez=ez)
% T1=eye(4); T2=T1; T2(1:3,4)=[1 7 40]; crossT(T2);
% T1=eye(4); T2=T1; T2(1:3,1:3)=rotdeg(90,0,0); crossT(T2)
%
plotL(T,c,s,w,N)- plots a HT-matrix as straight line
plotL(T,c,s,w,N) % plotL(T,c,s,w,N) - plots a HT-matrix as straight line
% (by Tim Lueth, HT-Lib, 2010-AUG-09 as class: VISUALIZATION)
%
% See also: pplot, lplot, tfplot, tlplot, slplot, plotTP, plotT, T2plot
%
% plotL(T,[c,s,w,N])
% === INPUT PARAMETERS ===
% T: HT matrix
% c: color, default = 'g-.'
% s: size, default = 10
% w: width, default = 2
% N: Text string
%
plotTP (T,f,a,c1,c2,c3)- plots the basic planes of a coordinate system
plotTP (T,f,a,c1,c2,c3) % plotTP (T,f,a,c1,c2,c3) - plots the basic planes of a coordinate system
% (by Tim Lueth, HT-Lib, 2010-AUG-09 as class: VISUALIZATION)
%
% ' ' returns blind planes
% '' returns a default color (Status of: 2017-01-29)
%
% See also: pplot, lplot, tfplot, tlplot, slplot, plotL, plotT, T2plot
%
% plotTP(T,[f,a,c1,c2,c3])
% === INPUT PARAMETERS ===
% T: HT matrix for coordinate system
% f: size of the plane
% a: transparency value
% c1: color of plane x
% c2: color of plane y
% c3: color of plane z
%
% EXAMPLE: plot three planes of size 10
% plotTP(eye(4),10);
%
tfplot (T,c,f,a)- plots an HT matrix including the x/y plane
tfplot (T,c,f,a) % tfplot (T,c,f,a) - plots an HT matrix including the x/y plane
% (by Tim Lueth, HT-Lib, 2010-AUG-09 as class: ANALYTICAL GEOMETRY)
%
% tfplot shows a 3D-plot figure of a HT Coordinate System and the
% x/y-plane. tfplot (T,c,f) shows the coordinate system of T and draws a
% closed plane of side length 2f in color c (Status of: 2017-01-29)
%
% See also: pplot, lplot, tlplot, slplot, plotTP, plotL, plotT, T2plot
%
% tfplot(T,[c,f,a])
% === INPUT PARAMETERS ===
% T: HT Matrix
% c: Color; default is 'r'
% f: size of plane; default is 1
% a: Transparency alpha, default is 0.5
%
% EXAMPLE: simple experiment
% T=eye(4), tfplot (T,'r',4), view (-30,30)
%
T2P(p,ez)- returns a 4x4 HT matrix given bei a point p and a vector ez
T2P(p,ez) % T2P(p,ez) - returns a 4x4 HT matrix given bei a point p and a vector ez
% (by Tim Lueth, VLFL-Lib, 2010-AUG-06 as class: ANALYTICAL GEOMETRY)
%
% T = T2P (p, ez) returns an homogeneous transformation matrix (HT) given
% by 1 points p and one vector ez. T2P can be used for describing a plane
% or a straight line as homogenous transformation matrix (HT) With p as
% transformation and ez as director of the z-axis, the two missing vector
% ex an ey are calculated from ez. If a plane is given by three points,
% please use T3P.
%
% Please have in mind, that there is an discontinuity that will leads to
% a strong turn of the T matrix in case of subsequent moving ez vectors.
% To avoid this, either quaternions or euler angle or a defined turning
% third point (T3P) must be used. (Status of: 2017-01-21)
%
% See also: TofR, TofVL, TPL, TofDPhiH, T3ofT2, T3P
%
% T=T2P(p,ez)
% === INPUT PARAMETERS ===
% p: Point of straight line
% ez: Direction of a straight line
% === OUTPUT RESULTS ======
% T: Matrix descibring a line using p and ez
%
T3P(p1,p2,p3)- returns a 4x4 HT matrix given by three points (sort3P)
T3P(p1,p2,p3) % T3P(p1,p2,p3) - returns a 4x4 HT matrix given by three points (sort3P)
% (by Tim Lueth, HT-Lib, 2010-AUG-06)
%
% T = T3P (p1, p2, p3) returns an homogenous transformation matrix (HT)
% calculated from 3 points p1, p2, p3:
% t=p1; R=(ex, ey, ez)
% ex=ex=(p2-p1)/norm(p2-p1)
% ez=z/norm(z); z=cross (ex,p3-p1);
% ey=cross (ez, ex);
% T=[ex ey ez p1(1:3); 0 0 0 1]
% if argument p1 is a vertex list, the first three points of VL are used
% (Status of: 2017-02-13)
%
% See also: TofR, TofVL, TPL, TofDPhiH, T3ofT2, T2P
%
% T=T3P(p1,p2,p3)
% === INPUT PARAMETERS ===
% p1: point 1 of the triangle, or VL
% p2: point 2 of the triangle
% p3: point 3 of the triangle
% === OUTPUT RESULTS ======
% T: HT Matrix describing the 3P coordinate system
%
pplot(p,c,w)- pplot shows a 3D-plot figure of a point or a list of points
pplot(p,c,w) % pplot(p,c,w) - pplot shows a 3D-plot figure of a point or a list of
% points
% (by Tim Lueth, HT-Lib, 2010-AUG-06 as class: VISUALIZATION)
%
% p is a list 2xn or 3xn (Status of: 2016-01-06)
%
% See also: pplot, lplot, tplot
%
% LITERATURE:
% - Kerle, H., Pittschellis, R. Corves, B. (2007): Einführung in die
% Getriebelehre, B.G. Teubner Verlag, 3. Auflage
%
% h=pplot(p,[c,w])
% === INPUT PARAMETERS ===
% p: Point or list of points to be plotted 2xn or 3xn
% c: Color and symbol of points
% w: width of the used line
% === OUTPUT RESULTS ======
% h: Handle to figure
%
lplot(p1,p2,c,w,ts,ss,str,fs)- plots a straight line between 2 points
lplot(p1,p2,c,w,ts,ss,str,fs) % lplot(p1,p2,c,w,ts,ss,str,fs) - plots a straight line between 2 points
% (by Tim Lueth, HT-Lib, 2010-JUL-01 as class: VISUALIZATION)
%
% plots a straight line between 2 points (Status of: 2017-04-04)
%
% See also: pplot, tfplot, aplot, tlplot, slplot, plotTP, plotL, plotT,
% T2Plot
%
% [hh,pt]=lplot(p1,p2,[c,w,ts,ss,str,fs])
% === INPUT PARAMETERS ===
% p1: Starting point
% p2: End point
% c: Color and symbol default is "r*-"
% w: line width; default is 1
% ts: tip size; 0==auto
% ss: start block size; 0==auto
% str: Text string at tip
% fs: font size of text
% === OUTPUT RESULTS ======
% hh: handle to all line elements
% pt: point between p1 and p2 for text
%
% EXAMPLE: draws a green line with an arrow at the tip and a text 'P'
% lplot ([0 ;0; 0],[1; 1; 1],'g',2,0,-1,'P',16);
%
plotT (T,s,w,N)- plots a coordinate system given as HT matrix
plotT (T,s,w,N) % plotT (T,s,w,N) - plots a coordinate system given as HT matrix
% (by Tim Lueth, HT-Lib, 2010-JUN-01 as class: ANALYTICAL GEOMETRY)
%
% Does support 2D (3x3) and 3D (4x4) HT matrices (Status of: 2017-01-29)
%
% See also: pplot, lplot, tfplot, tlplot, slplot, plotTP, plotL, T2plot
%
% plotT(T,[s,w,N])
% === INPUT PARAMETERS ===
% T: HT matrix of the coordinate system
% s: size of the unit vectors, default is 1
% w: width of the matlab lines, default is 1
% N: Name of coordinate system
%
% EXAMPLE: Plots the Origin
% plotT(eye(4),1,2,'A');
%