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) - 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) - 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) - 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() - 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) - 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) - 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); - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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 - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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 - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 |
 |
% 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) - 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 - 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 - 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) - 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 - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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 - 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 - 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) - 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) - 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 - 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) - 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 - 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 - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - % (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 - 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) - 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 - 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) - 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) - 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) - 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 - 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 - 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 - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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 - % (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 - 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 - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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 - 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) - 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 - 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) - 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) - 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 - 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) - 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) - 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 |
 |
%% 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) - 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 - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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 - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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 - 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) - 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 - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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 () - 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,) - 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) - 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) - 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) - 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) - 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) - 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) - 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 () - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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; - 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) - 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) - 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) - 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) - 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) - 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,) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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); - 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) - 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) - 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) - 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) - 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() - 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) - 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 - 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) - 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 - 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); - 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( % pcodeTL( % pcodeTL( % (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); - 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( % pcodeTL( % pcodeTL( % (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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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 - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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 - 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 - 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) - 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 - 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) - 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 - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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 - 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) - 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) - 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; - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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); - 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) - 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) - 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) - 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) - 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); - 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); - 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); - 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) - 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 - % (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) - 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) - 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) - 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) - 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) - 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) - 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) - 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); - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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); - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 |
 |
% 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) - 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 - 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) - 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) - 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 - 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) - 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) - 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) - 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 - 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_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) - 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) - 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) - 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 - 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) - 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) - 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 - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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 - 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) - 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) - 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) - 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) - 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) - 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 - 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 - 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 - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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) - 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 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) - 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) - 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'); % |