Basic geometry definitions. More...
#include "../ut/ut_types.h"#include "../ut/ut_umem.h"Go to the source code of this file.
Data Structures | |
| struct | Quat |
| quaternion More... | |
| struct | dcomplex |
| struct | polcoeff_d3 |
| struct | polcoeff_d4 |
| struct | polcoeff_d5 |
| struct | polynom_d3 |
| Typ_polynom_d3 Typ_CVPSP3. More... | |
| struct | Polynom1 |
| Typ_Polynom1. More... | |
| struct | Polynom3 |
| Typ_Polynom3. More... | |
| struct | Polynom_ |
| Typ_Polynom_. More... | |
| struct | Point2 |
| 2D-point, Typ_PT2 More... | |
| struct | Point |
| 3D-point, Typ_PT More... | |
| struct | Vector2 |
| 2D-vector, Typ_VC2 More... | |
| struct | Vector |
| 3D-vector, Typ_VC More... | |
| struct | Ray |
| struct | Line2 |
| 2D-line, Typ_LN2 More... | |
| struct | Line |
| 3D-line, Typ_LN More... | |
| struct | Triangle |
| triangle, Typ_Tria More... | |
| struct | Circ2 |
| 2D-circle, Typ_CI2, Typ_AC2 More... | |
| struct | Circ |
| 3D-circle, Typ_CI, Typ_AC More... | |
| struct | CurvElli |
| ellipse, Typ_CVELL More... | |
| struct | Curv |
| do not use; replaced by ObjGX More... | |
| struct | CurvPoly |
| Curve: polygon, Typ_CVPOL. More... | |
| struct | CurvBSpl |
| Curve: B-spline Typ_CVBSP. More... | |
| struct | CurvRBSpl |
| Rational B-Spline-curve; Typ_CVRBSP. More... | |
| struct | CurvBez2 |
| 2D-Bezier curve Typ_CVBEZ2 More... | |
| struct | CurvBez |
| Bezier curve Typ_CVBEZ. More... | |
| struct | CurvRBez |
| Rational Bezier curve Typ_CVRBEZ. More... | |
| struct | CurvClot |
| Clothoid curve Typ_CVCLOT. More... | |
| struct | CurvCCV |
| Concatenated curve Typ_CVCCV. More... | |
| struct | Plane |
| 3D-plane, Typ_PLN More... | |
| struct | SurHat |
| Hatch Typ_SURHAT. More... | |
| struct | SurRev |
| RevolvedSurf Typ_SURRV. More... | |
| struct | SurStd |
| StandardSurf (planar, conic, toroid) Typ_SUR. More... | |
| struct | SurStripe |
| surface from group of stripes; stripe from 2 polygons. More... | |
| struct | SurBSpl |
| Area: B-Spline-Surf Typ_SURBSP. More... | |
| struct | SurRBSpl |
| Area: Rat.B-Spline-Surf Typ_SURRBSP. More... | |
| struct | ColRGB |
| color, Typ_Color More... | |
| struct | AText |
| text or image or label; Typ_ATXT, Typ_Tag .. More... | |
| struct | TexBas |
| basic texture description; Typ_TEXB More... | |
| struct | TexRef |
| texture reference; Typ_TEXR More... | |
| struct | GText |
| grafic text; Typ_GTXT More... | |
| struct | Ditto |
| internal submodel (block); Typ_Ditto More... | |
| struct | ModelMock |
| internal submodel reference; Typ_Mock More... | |
| struct | ModelBas |
| basic model description; Typ_SubModel More... | |
| struct | ModelRef |
| model reference; Typ_Model More... | |
| struct | ModelNode |
| Typ_ModelNode. More... | |
| struct | Sphere |
| sphere; Typ_SPH More... | |
| struct | Conus |
| cone; Typ_CON More... | |
| struct | Torus |
| torus; Typ_TOR More... | |
| struct | Dimen |
| dimension; Typ_Dimen More... | |
| struct | Dim3 |
| 3D-dimension; Typ_Dim3 More... | |
| struct | SymRef2 |
| 2D-symbol; Typ_SymRef2 Typ_SymB Typ_SymV More... | |
| struct | SymRef |
| 3D-symbol; Typ_SymRef More... | |
| struct | GR_Att |
| struct | ObjAtt |
| PermanentAttributRecord. More... | |
| struct | DL_Att |
| DisplayListRecord. More... | |
| struct | TraRot |
| Typ_TraRot: More... | |
| struct | Activity |
| Typ_Activ ("I"). More... | |
| struct | Verts |
| struct | Face |
| struct | Fac3 |
| struct | Faces |
| struct | FacNf |
| Face with NeigbourFaces. More... | |
| struct | Edge |
| ipt: index points; More... | |
| struct | Edg3 |
| i1, i2 index to points More... | |
| struct | EdgeLine |
| Typ_EdgeLine. More... | |
| struct | Edges |
| struct | Mesh |
| Typ_SURMSH 2007-03-24 TB. More... | |
| struct | BTool |
| struct | ObjGX |
| Typ_ObjGX. More... | |
| struct | ObjDB |
| Typ_Group DB-Objects Typ_ObjDB. More... | |
| struct | ObjSRC |
| Typ_ObjSRC sourceObject. More... | |
| struct | ObjAto |
| atomicObjects More... | |
| struct | ObjG2 |
| struct | ObjG |
| DO NOT USE; replaced by ObjGX. More... | |
| struct | ObjBin |
| struct | ContTab |
| ContourCurve. More... | |
| struct | ObjRange |
| group of consecutive objects More... | |
| union | uni_i4i2 |
| union long / short[2] More... | |
| struct | stru_2i2 |
| int = short + short More... | |
| struct | stru_c3c1 |
| int = char[4] + char More... | |
Defines | |
| #define | RAD_360 6.2831853071795862319 |
| 360 Grad | |
| #define | RAD_270 4.7123889803846896739 |
| 270 Grad | |
| #define | RAD_225 3.92699081698724151736 |
| 225 Grad | |
| #define | RAD_180 3.14159265358979323846 |
| 180 Grad | |
| #define | RAD_135 2.3561944901923448368 |
| 135 Grad | |
| #define | RAD_90 1.5707963267948965579 |
| 90 Grad | |
| #define | RAD_60 1.0471975511965976313 |
| 60 Grad | |
| #define | RAD_45 0.7853981633974482789 |
| 45 Grad | |
| #define | RAD_30 0.5235987755982988156 |
| 30 Grad | |
| #define | RAD_10 0.174532925199432954 |
| 10 Grad | |
| #define | RAD_1 0.0174532925199432954 |
| 1 Grad | |
| #define | RAD_01 0.0017453292519943295 |
| 0.1 Grad | |
| #define | SR_3 1.7320508075688772 |
| SQRT(3). | |
| #define | SR_2 1.4142135623730951 |
| SQRT(2). | |
| #define | SR_PI 1.7724538509055159 |
| SQRT(PI) = SQRT(RAD_180). | |
| #define | CCW 1 |
| counterclockwise | |
| #define | CW -1 |
| clockwise | |
| #define | YES 0 |
| FALSE. | |
| #define | NO 1 |
| TRUE. | |
| #define | ON 0 |
| FALSE. | |
| #define | OFF 1 |
| TRUE. | |
| #define | LIMITED 0 |
| #define | UNLIMITED 1 |
| #define | Typ_Error 0 |
| U0 = undefined. | |
| #define | Typ_VAR 1 |
| V numer. variable. | |
| #define | Typ_PT 2 |
| P Point. | |
| #define | Typ_LN 3 |
| L Line. | |
| #define | Typ_CI 4 |
| C do not use; use Typ_AC. | |
| #define | Typ_AC 5 |
| C Circ. | |
| #define | Typ_VC 6 |
| D Vector. | |
| #define | Typ_CV 7 |
| S all curves. | |
| #define | Typ_CVPOL 8 |
| S CurvPoly. | |
| #define | Typ_CVPSP3 9 |
| S polynom_d3. | |
| #define | Typ_CVBSP 10 |
| S CurvBSpl. | |
| #define | Typ_CVRBSP 11 |
| S CurvRBSpl. | |
| #define | Typ_CVCCV 12 |
| S CurvCCV. | |
| #define | Typ_CVELL 13 |
| S CurvElli. | |
| #define | Typ_CVBEZ 14 |
| S CurvBez. | |
| #define | Typ_CVRBEZ 15 |
| S CurvRBez. | |
| #define | Typ_CVCLOT 16 |
| S ClothoidCurve (CurvClot). | |
| #define | Typ_CVLNA 18 |
| S array of lines (form=Typ_LN). | |
| #define | Typ_SymRef 17 |
| SymRef. | |
| #define | Typ_Vertex 19 |
| Vertex; point on existing object. | |
| #define | Typ_lFig 20 |
| Linear Obj; LN/CI/CV. | |
| #define | Typ_EdgeLine 21 |
| #define | Typ_PT2 22 |
| P Point2. | |
| #define | Typ_LN2 23 |
| L Line2. | |
| #define | Typ_AC2 24 |
| C Circ2. | |
| #define | Typ_CI2 25 |
| C do not use; use Typ_AC2. | |
| #define | Typ_VC2 26 |
| D Vector2. | |
| #define | Typ_CV2 27 |
| S all 2D-curves. | |
| #define | Typ_CVPOL2 28 |
| S CurvPoly-2D. | |
| #define | Typ_CVPSP2 29 |
| S polynom_? | |
| #define | Typ_CVBSP2 30 |
| S CurvBSpl-2D. | |
| #define | Typ_CVRBSP2 31 |
| S CurvRBSpl-2D. | |
| #define | Typ_CVCCV2 32 |
| #define | Typ_CVELL2 33 |
| S CurvElli-2D. | |
| #define | Typ_CVBEZ2 34 |
| S CurvBez2. | |
| #define | Typ_SymRef2 35 |
| SymRef2. | |
| #define | Typ_SUR 50 |
| Surfaces. | |
| #define | Typ_SURCIR 51 |
| tesselated fan | |
| #define | Typ_SURSTRIP 52 |
| tesselated strip | |
| #define | Typ_SURRU 53 |
| A Ruled Sur. | |
| #define | Typ_SURRV 54 |
| A Revolved Sur. | |
| #define | Typ_SURBSP 55 |
| A B_Spline_Surf SurBSpl. | |
| #define | Typ_SURRBSP 56 |
| A Rat.B_Spline Surf SurRBSpl. | |
| #define | Typ_SURPLN 57 |
| A Planar surf. | |
| #define | Typ_SURCON 58 |
| Conus (unused). | |
| #define | Typ_SURTOR 59 |
| Torus (unused). | |
| #define | Typ_PLN 60 |
| R plane/Refsys. | |
| #define | Typ_SURTPS 62 |
| A surface-trimmed-perforated-supported. | |
| #define | Typ_SURMSH 63 |
| A Mesh. | |
| #define | Typ_SURPTAB 64 |
| A surf from PTAB. | |
| #define | Typ_SURHAT 65 |
| A Hatch. | |
| #define | Typ_Fac3 66 |
| Triangle; Form = Fac3. | |
| #define | Typ_QFac 67 |
| Triangle;. | |
| #define | Typ_Tria 68 |
| Triangle; Form = Triangle (unused). | |
| #define | Typ_GL_Sur 70 |
| tesselated surface | |
| #define | Typ_GL_PP 71 |
| tesselated planar patch | |
| #define | Typ_GL_CV 72 |
| Polygon. | |
| #define | Typ_SOL 80 |
| bodies | |
| #define | Typ_SPH 81 |
| B sphere. | |
| #define | Typ_CON 82 |
| B Conus (Cylinder). | |
| #define | Typ_TOR 83 |
| B Torus. | |
| #define | Typ_PRI 84 |
| B Prism. | |
| #define | Typ_Note 90 |
| notes, images | |
| #define | Typ_ATXT 91 |
| N AText. | |
| #define | Typ_GTXT 92 |
| N GText. | |
| #define | Typ_Dimen 93 |
| N. | |
| #define | Typ_Dim3 94 |
| N. | |
| #define | Typ_Tag 95 |
| N Bitmap (Blocknote, Image ..). | |
| #define | Typ_SymB 96 |
| bitmap symbols: SYM_TRI_S SYM_STAR_S .. | |
| #define | Typ_SymV 97 |
| Vektorymbole: SYM_PLANE SYM_ARROW .. | |
| #define | Typ_Texture 100 |
| index to TexRef | |
| #define | Typ_TEXB 101 |
| Base-Texture TexBas. | |
| #define | Typ_TEXR 102 |
| Ref-Texture TexRef. | |
| #define | Typ_TmpPT 110 |
| temp objs | |
| #define | Typ_TmpLN 111 |
| temporary Line | |
| #define | Typ_TmpVC 113 |
| temporary Vector | |
| #define | Typ_TmpSym 114 |
| temporary Symbol | |
| #define | Typ_TmpTRI 115 |
| temporary triangle | |
| #define | Typ_TmpPLN 116 |
| temporary Plane | |
| #define | Typ_EyePT 117 |
| #define | Typ_Box 118 |
| #define | Typ_Part 120 |
| geom. attributes | |
| #define | Typ_Group 121 |
| U ObjDB DB-Objects (union-group). | |
| #define | Typ_SubModel 122 |
| M - basicModel. | |
| #define | Typ_Model 123 |
| M - ModelReference ModelRef. | |
| #define | Typ_Mock 124 |
| #define | Typ_Ditto 125 |
| #define | Typ_Joint 126 |
| connection, exported; | |
| #define | Typ_Val 130 |
| geom. parameters TYP_IS_GEOMPAR | |
| #define | Typ_ValX 131 |
| X-coord. | |
| #define | Typ_ValY 132 |
| Y-coord. | |
| #define | Typ_ValZ 133 |
| Z-coord. | |
| #define | Typ_XVal 134 |
| X-distance. | |
| #define | Typ_YVal 135 |
| Y-distance. | |
| #define | Typ_ZVal 136 |
| Z-distance. | |
| #define | Typ_Angle 137 |
| Angle (in degree). | |
| #define | Typ_Rad 138 |
| Radius. | |
| #define | Typ_Dist 139 |
| distance | |
| #define | Typ_Par1 140 |
| Parameter 0-1; for knotvals use Typ_Val. | |
| #define | Typ_UVal 141 |
| #define | Typ_VVal 142 |
| #define | Typ_AngN 143 |
| #define | Typ_AngP 144 |
| #define | Typ_RadISO 145 |
| #define | Typ_Conic 146 |
| #define | Typ_Typ 150 |
| attributes | |
| #define | Typ_Subtyp 151 |
| #define | Typ_cmdNCsub 152 |
| #define | Typ_Address 153 |
| form of ObjGX-Record defines dataPosition | |
| #define | Typ_Size 154 |
| recordSize for following record | |
| #define | Typ_Index 155 |
| int or long | |
| #define | Typ_Name 156 |
| #define | Typ_Color 157 |
| ColRGB. | |
| #define | Typ_Ltyp 158 |
| line type | |
| #define | Typ_Thick 159 |
| line thickness | |
| #define | Typ_G_Att 160 |
| G. | |
| #define | Typ_Activ 161 |
| I = Interactivity. | |
| #define | Typ_Layer 162 |
| #define | Typ_APPOBJ 163 |
| #define | Typ_apDat 164 |
| application-data Typ_APPOBJ | |
| #define | Typ_Tool 165 |
| #define | Typ_Data 170 |
| dataFormats (Int, matrix, Polynom..) | |
| #define | Typ_Int1 171 |
| 8 bit (char) | |
| #define | Typ_Int2 172 |
| 16 bit (short) | |
| #define | Typ_Int4 173 |
| 32 bit (int, long) | |
| #define | Typ_Float4 174 |
| 32 bit (float) | |
| #define | Typ_Float8 175 |
| 64 bit (double) | |
| #define | Typ_Polynom_ 176 |
| #define | Typ_Polynom1 177 |
| Polynom1. | |
| #define | Typ_Polynom3 178 |
| Polynom3. | |
| #define | Typ_polynom_d3 179 |
| #define | Typ_M3x2 181 |
| Mat_3x2. | |
| #define | Typ_M3x3 182 |
| Mat_3x3. | |
| #define | Typ_M4x3 183 |
| Mat_4x3. | |
| #define | Typ_M4x4 184 |
| Mat_4x4. | |
| #define | Typ_Txt 190 |
| text | |
| #define | Typ_String 191 |
| durch " begrenzt | |
| #define | Typ_StrDel 192 |
| StringDelimiter "\" Fortsetzungszeile. | |
| #define | Typ_StrDel1 193 |
| StringDelimiter 1 "|". | |
| #define | Typ_FncNam 194 |
| #define | TYP_FilNam 195 |
| filename | |
| #define | Typ_CtlgPart 196 |
| catalogpart | |
| #define | Typ_Memspc 200 |
| containers | |
| #define | Typ_MemTab 201 |
| MemTab ../ut/ut_memTab.h. | |
| #define | Typ_ObjRange 202 |
| ObjRange. | |
| #define | Typ_ObjSRC 203 |
| ObjSRC. | |
| #define | Typ_ObjGX 204 |
| ObjGX. | |
| #define | Typ_ObjG2 205 |
| deprec | |
| #define | Typ_ObjG 206 |
| deprec | |
| #define | Typ_ObjDB 207 |
| ObjDB. | |
| #define | Typ_Tra 210 |
| transformations | |
| #define | Typ_TraTra 211 |
| Translation dzt unused; Typ_VC used. | |
| #define | Typ_TraRot 212 |
| Rotation TraRot. | |
| #define | Typ_TraMat 213 |
| Matrixtransformation. | |
| #define | Typ_ope_eq 220 |
| operators | |
| #define | Typ_ope_ne 221 |
| operator != | |
| #define | Typ_ope_lt 222 |
| operator < | |
| #define | Typ_ope_gt 223 |
| operator > | |
| #define | Typ_ope_ge 224 |
| operator >= | |
| #define | Typ_ope_le 225 |
| operator <= | |
| #define | Typ_ope_and 226 |
| operator & | |
| #define | Typ_ope_or 227 |
| operator | | |
| #define | Typ_modif 230 |
| modifiers TYP_IS_MOD | |
| #define | Typ_mod1 231 |
| Modifier; Value depends. | |
| #define | Typ_mod2 232 |
| Modifier; Value depends. | |
| #define | Typ_modCWCCW 233 |
| Modifier; CW CCW. | |
| #define | Typ_modREV 234 |
| Modifier; Reverse. | |
| #define | Typ_modCX 235 |
| Modifier ACROSS (V-direction). | |
| #define | Typ_modCTRL 236 |
| #define | Typ_modPERP 237 |
| perpendicular (right angled; default = parall) | |
| #define | Typ_modPARL 238 |
| parallel (U-direction) | |
| #define | Typ_modHIX 239 |
| #define | Typ_modLOX 240 |
| #define | Typ_modHIY 241 |
| #define | Typ_modLOY 242 |
| #define | Typ_modHIZ 243 |
| #define | Typ_modLOZ 244 |
| #define | Typ_modCCW 245 |
| #define | Typ_modCW 246 |
| #define | Typ_modIN 247 |
| #define | Typ_modOUT 248 |
| #define | Typ_modAux 249 |
| Modifier; on|off; text=last infoWord. | |
| #define | TYP_EvMouseL 250 |
| events DO NOT USE - replaced by TYP_Event* ../ut/types_gui.h | |
| #define | TYP_EvMouseM 251 |
| event mid mousebutton | |
| #define | TYP_EvMouseR 252 |
| event right mousebutton | |
| #define | TYP_EvMouse2L 253 |
| event doubleclick | |
| #define | TYP_FuncInit 260 |
| functions see also UI_Func* ../ut/types_gui.h | |
| #define | TYP_FuncInit1 261 |
| function | |
| #define | TYP_FuncMod 262 |
| function modify | |
| #define | TYP_FuncAdd 263 |
| function add | |
| #define | TYP_FuncDel 264 |
| function delete | |
| #define | TYP_FuncEnd 265 |
| function end | |
| #define | TYP_FuncExit 266 |
| function exit | |
| #define | TYP_SIZ 270 |
| nr of defined types | |
| #define | Typ_ALL 270 |
| function parameters | |
| #define | Typ_Done 271 |
| #define | Typ_NULL 272 |
| nothing, empty; Typ_unknown | |
| #define | Typ_last 273 |
| #define | TYP_OpmPlus 280 |
| math.operators | |
| #define | TYP_OpmMinus 281 |
| #define | TYP_OpmMult 282 |
| #define | TYP_OpmDiv 283 |
| #define | Typ_FcmSQRT 290 |
| math.functions | |
| #define | Typ_FcmSIN 291 |
| #define | Typ_FcmCOS 292 |
| #define | Typ_FcmTAN 293 |
| #define | Typ_FcmASIN 294 |
| #define | Typ_FcmACOS 295 |
| #define | Typ_FcmATAN 296 |
| #define | Typ_FcmABS 297 |
| #define | Typ_FcmFIX 298 |
| #define | Typ_FcmRND 299 |
| #define | BCKPLN_XY 2 |
| Z-Vec BCKVEC_Z. | |
| #define | BCKPLN_XZ 1 |
| Y-Vec BCKVEC_Y. | |
| #define | BCKPLN_YZ 0 |
| X-Vec BCKVEC_X. | |
| #define | BCKVEC_Z 2 |
| Z-Vec BCKPLN_XY. | |
| #define | BCKVEC_Y 1 |
| Y-Vec BCKPLN_XZ. | |
| #define | BCKVEC_X 0 |
| X-Vec BCKPLN_YZ. | |
| #define | GL_TRIANGLE_NPFAN 16 |
| non planar fan (GL_TRIANGLE_FAN = planar) | |
| #define | Mtyp_Gcad 0 |
| #define | Mtyp_DXF 1 |
| #define | Mtyp_Iges 2 |
| #define | Mtyp_Step 3 |
| #define | Mtyp_3DS 4 |
| #define | Mtyp_LWO 5 |
| #define | Mtyp_XML 6 |
| #define | Mtyp_WRL 10 |
| VRML1 10-19 tess-Formate. | |
| #define | Mtyp_WRL2 110 |
| VRML2. | |
| #define | Mtyp_OBJ 11 |
| #define | Mtyp_STL 12 |
| #define | Mtyp_TESS 13 |
| #define | Mtyp_BMP 20 |
| 20-29 PixelImages | |
| #define | Mtyp_JPG 21 |
| #define | MBTYP_EXTERN 0 |
| #define | MBTYP_INTERN -1 |
| #define | MBTYP_CATALOG -2 |
| #define | TimeStamp float |
| #define | OBJ_SIZ_MAX 160 |
| 160 = 5 * 32 | |
| #define | UT_BEZDEG_MAX 50 |
| maximal degree of Bezier curve | |
| #define | ATT_BIT_ABS 1 |
| das Absolut-Bit; Achtung: 0=ON=absolut, 1=relativ. | |
| #define | ATT_BIT_LIM 2 |
| Limited; 0=On; 2=unbegrenzte Linie/Vollkreis. | |
Typedefs | |
| typedef double | Mat_3x2 [2][3] |
| Typ_M3x2. | |
| typedef double | Mat_3x3 [3][3] |
| Typ_M3x3. | |
| typedef double | Mat_4x3 [3][4] |
| Typ_M4x3 size 96. | |
| typedef double | Mat_4x4 [4][4] |
| Typ_M4x4. | |
Functions | |
| int | MEM_swap__ (void *stru1, void *stru2, long strSiz) |
| int | MEM_swap_short (short *i1, short *i2) |
| int | MEM_swap_int (int *i1, int *i2) |
| int | MEM_swap_2db (double *d1, double *d2) |
| int | MEM_ins_rec (void *insPos, long movSiz, void *insDat, long insSiz) |
| int | MEM_chg_rec (void *datStart, long *datSiz, void *insDat, long insSiz, void *delPos, long delSiz) |
| int | MEM_ins_nrec (int *recNr, void *recTab, int ipos, void *insDat, int insRecNr, int sizRec) |
| int | MEM_del_nrec (int *recNr, void *recTab, int ipos, int delRecNr, int sizRec) |
| int | MEM_del_IndRec (int *recNr, void *recTab, int ipos) |
| int | MEM_del_DbRec (int *recNr, void *recTab, int ipos) |
| void | MEM_del_pt (int *recNr, Point *pa, int recInd) |
| void * | MEM_ptr_mov (void *ptr, long dist) |
| int | UTP_comp_0 (double) |
| int | UTP_compdb0 (double, double) |
| int | UTP_comp2db (double, double, double) |
| int | UTP_comp2x2db (double d11, double d12, double d21, double d22, double tol) |
| int | UTP_db_ck_in2db (double v, double v1, double v2) |
| int | UTP_db_ck_in2dbTol (double v, double v1, double v2, double tol) |
| int | UTP_db_cknear_2db (double *db, double *d1, double *d2) |
| int | UTP_db_cknear_ndb (double db1, int dbNr, double *dbTab) |
| double | UTP_db_rnd1sig (double) |
| double | UTP_db_rnd2sig (double) |
| int | UT1D_ndb_npt_bp (double *da, Point *pa, int pNr, int bp) |
| double | UT_DEGREES (double) |
| double | UT_RADIANS (double) |
| int | UT2D_sidPerp_3pt (Point2 *p1, Point2 *p2, Point2 *p3) |
| int | UT2D_angr_set (double *angr) |
| int | UT2D_2angr_set (double *ang1, double *ang2, int irot) |
| double | UT2D_angr_2angr (double ang1, double ang2, int irot) |
| int | UT2D_ptNr_ci (double rdc, double ao, double tol) |
| int | UT2D_solvtriri_a (double *a, double b, double c) |
| int | UT2D_solvtriri_ac (double *, double *, double, double) |
| int | UT2D_solvtri_abc (double *, double *, double, double, double) |
| int | UT2D_ckBoxinBox1 (Point2 *p1, Point2 *p2, Point2 *p3, Point2 *p4) |
| int | UT2D_ckBoxinBox2 (Point2 *, Point2 *, Point2 *, Point2 *, double) |
| double | UT2D_skp_2vc (Vector2 *, Vector2 *) |
| double | UT2D_skp_vc2pt (Vector2 *, Point2 *, Point2 *) |
| double | UT2D_acos_2vc (Vector2 *, Vector2 *) |
| double | UT2D_sar_2vc (Vector2 *, Vector2 *) |
| double | UT2D_acos_vc2pt (Vector2 *, Point2 *, Point2 *) |
| double | UT2D_crossprod_2vc (Vector2 *, Vector2 *) |
| double | UT2D_angd_angr (double) |
| double | UT2D_angd_invert (double *andi) |
| double | UT2D_angr_angd (double) |
| double | UT2D_angr_triri_ab (double, double) |
| double | UT2D_angr_ptpt (Point2 *, Point2 *) |
| double | UT2D_angr_vc (Vector2 *) |
| double | UT2D_angr_2ln (Line2 *, Line2 *) |
| double | UT3D_angr_vc2pt (Point *pz, Vector *vz, Point *p1, Point *p2) |
| double | UT3D_angr_vcpl_z (Plane *pl1, Vector *vc1) |
| double | UT3D_angr_vcpl_tilt (Plane *pl1, Vector *vc1) |
| double | UT3D_angr_vc2vc (Vector *vc1, Vector *vcx, Vector *vcy) |
| double | UT3D_angr_2pl (Plane *pl1, Plane *pl2) |
| double | UT2D_angr_2vc (Vector2 *, Vector2 *) |
| double | UT2D_angr_3ptdr (Point2 *, Point2 *, Point2 *, int) |
| double | UT3D_angr_4pt (Point *p11, Point *p12, Point *p21, Point *p22) |
| double | UT2D_angr_ci (Point2 *pa, Point2 *pe, Point2 *pc, double rad_in) |
| double | UT3D_angr_cipt (Circ *ci1, Point *pti) |
| double | UT2D_angr_perpangr (double *) |
| double | UT2D_len_vc (Vector2 *) |
| double | UT2D_lenq_vc (Vector2 *) |
| void | UT2D_lenq_2pt (double *lq, Point2 *p1, Point2 *p2) |
| double | UT2D_len_2pt (Point2 *, Point2 *) |
| double | UT2D_lenB_2pt (Point2 *p1, Point2 *p2) |
| int | UT2D_minLenB_4pt (double *dp, Point2 *, Point2 *, Point2 *, Point2 *) |
| int | UT3D_minLen_3pt (double *, Point *, Point *, Point *) |
| int | UT3D_minLen_4pt (double *, Point *, Point *, Point *, Point *) |
| double | UT2D_len_ptln (Point2 *pt, Point2 *pa, Point2 *pe) |
| int | UT2D_3len_ptln (double *, double *, double *, Point2 *, Point2 *, Point2 *) |
| int | UT2D_slenq_ptptvc (double *qlen, Point2 *pa, Point2 *pb, Point2 *pc) |
| double | UT2D_slen_nor3pt (Point2 *p1, Point2 *p2, Point2 *p3) |
| double | UT2D_slen_nor2vc (Vector2 *v1, Vector2 *v2) |
| double | UT2D_slen_norvc2pt (Vector2 *v1, Point2 *p1, Point2 *p2) |
| double | UT2D_len_ptlnX (Point2 *pt, Point2 *pl, Vector2 *vl) |
| double | UT2D_len_ptlnY (Point2 *pt, Point2 *pl, Vector2 *vl) |
| void | UT2D_2len_ptvc (double *, double *, Point2 *, Point2 *, Vector2 *) |
| int | UT2D_irot_r (double r) |
| int | UT2D_sid_2vc (Vector *v1, Vector *v2) |
| int | UT2D_sidPerp_2vc (Vector *v1, Vector *v2) |
| int | UT2D_sid_3pt (Point2 *pt, Point2 *p1, Point2 *p2) |
| int | UT2D_sid_ptvc (Point2 *, Point2 *, Vector2 *) |
| int | UT2D_sidPerp_ptvc (Point2 *pt, Point2 *pl, Vector2 *vl) |
| int | UT3D_sid_2vc (Vector *v1, Vector *v2) |
| int | UT3D_sid_3pt (Point *p1, Point *p2, Point *p3) |
| int | UT3D_sid_ptpl (Point *pt, Plane *pl) |
| int | UT3D_sid_ptptvc (Point *ptx, Point *pto, Vector *vz) |
| int | UT2D_parLn_pt2pt (double *d1, Point2 *p1, Point2 *p2, Point2 *px) |
| double | UT2D_ar_3pt (Point2 *p1, Point2 *p2, Point2 *p3) |
| int | UT2D_comp2pt (Point2 *, Point2 *, double) |
| int | UT2D_comp4pt (Point2 *, Point2 *, Point2 *, Point2 *, double) |
| int | UT2D_pt_ck_int4pt (Point2 *, Point2 *, Point2 *, Point2 *) |
| int | UT2D_pt_ck_onLine (Point2 *po, Point2 *p1, Point2 *p2, Point2 *p3, double tol) |
| int | UT2D_pt_ck_inLine (Point2 *p1, Point2 *p2, Point2 *p3, double tol) |
| int | UT2D_pt_ck_inplg (Point2 *pTab, int pNr, Point2 *ptx) |
| int | UT2D_pt_ck_linear (int np, Point2 *ptab, double tol) |
| int | UT2D_pt_ck_inBox (Point2 *p1, Point2 *p2, Point2 *p) |
| int | UT2D_pt_ck_inBoxTol (Point2 *p1, Point2 *p2, Point2 *p, double tol) |
| int | UT2D_pt_ck_inAc (Point2 *pt, Circ2 *ci) |
| int | UT2D_pt_ck_inTriangle (Point2 *p1, Point2 *p2, Point2 *p3, Point2 *p) |
| int | UT2D_pt_ck_inCv3 (Point *ptx, int pNr, Point *pTab) |
| int | UT2D_pt_cknear_npt (Point2 *p0, Point2 *ptTab, int ptNr) |
| void | UT2D_swap2pt (Point2 *p1, Point2 *p2) |
| Point2 | UT2D_pt_pt3 (Point *) |
| void | UT2D_pt_2db (Point2 *, double, double) |
| int | UT3D_pt_pt2bp (Point *p3, Point2 *p2, int bp) |
| void | UT2D_pt_addpt (Point2 *, Point2 *) |
| void | UT2D_pt_opp2pt (Point2 *, Point2 *, Point2 *) |
| void | UT2D_pt_mid2pt (Point2 *, Point2 *, Point2 *) |
| void | UT2D_pt_traptvc (Point2 *, Point2 *, Vector2 *) |
| void | UT2D_pt_tra2ptlen (Point2 *, Point2 *, Point2 *, double) |
| void | UT2D_pt_traPtPtPar (Point2 *po, Point2 *p1, Point2 *p2, double d1) |
| void | UT2D_pt_tra3ptlen (Point2 *, Point2 *, Point2 *, Point2 *, double) |
| void | UT2D_pt_tra2pt2len (Point2 *, Point2 *, Point2 *, double, double) |
| void | UT2D_pt_tra2pt3len (Point2 *, Point2 *, Point2 *, double, double, double) |
| void | UT2D_pt_traptvclen (Point2 *, Point2 *, Vector2 *, double) |
| void | UT2D_pt_traptangrlen (Point2 *, Point2 *, double, double) |
| void | UT2D_pt_tranor2ptlen (Point2 *, Point2 *, Point2 *, double) |
| void | UT2D_pt_tranorptvclen (Point2 *, Point2 *, Vector2 *, double) |
| void | UT2D_pt_traptvc2len (Point2 *, Point2 *, Vector2 *, double, double) |
| void | UT2D_pt_tracirlen (Point2 *, Point2 *, Point2 *, double, double) |
| void | UT2D_pt_rotptangr (Point2 *, Point2 *, Point2 *, double) |
| int | UT2D_pt_projptptvc (Point2 *, Point2 *, Point2 *, Vector2 *) |
| int | UT2D_pt_projpt2pt (Point2 *pp, double *len, Point2 *pt, Point2 *p1, Point2 *p2) |
| int | UT2D_pt_projptln (Point2 *, Point2 *, Line2 *) |
| void | UT2D_2pt_projptci (Point2 *, Point2 *, Point2 *, Point2 *, double) |
| int | UT2D_pt_projptci (Point2 *pp, Point2 *pt, Circ2 *ci1) |
| int | UT3D_ptDi_intptvcptvc (Point *ip, double *dist, Point *ptl, Vector *vcl, Point *ptp, Vector *vcp) |
| int | UT3D_ptDi_intptvcpln (Point *ip, double *dist, Plane *pl, Point *pt, Vector *vln) |
| int | UT2D_pt_int4pt (Point2 *, double *, double *, Point2 *, Point2 *, Point2 *, Point2 *) |
| int | UT2D_pt_int2ln (Point2 *, Line2 *, Line2 *) |
| int | UT2D_pt_intptvcy (Point2 *pto, Point2 *ptl, Vector2 *vcl, double yVal) |
| int | UT2D_pt_intlny (Point2 *pto, Point2 *lp1, Point2 *lp2, double yVal) |
| int | UT2D_pt_int2pt2vc (Point2 *ip, Point2 *pt1, Vector2 *vc1, Point2 *pt2, Vector2 *vc2) |
| int | UT2D_pt_int2vc2pt (Point2 *, Point2 *, Vector2 *, Point2 *, Vector2 *) |
| int | UT2D_2pt_intciptvc (Point2 *, Point2 *, Point2 *, double, Point2 *, Vector2 *) |
| int | UT2D_2pt_intlnci (Point2 *ip1, Point2 *ip2, Line2 *ln, int lnMode, Circ2 *ci, int ciMode) |
| int | UT2D_2pt_intcici (Point2 *, Point2 *, Point2 *, double, Point2 *, double) |
| int | UT2D_2pt_int2ci (Point2 *ip1, Point2 *ip2, Circ2 *ci1, int ci1Mode, Circ2 *ci2, int ci2Mode) |
| void | UT2D_pt_traptm2 (Point2 *, Mat_3x2, Point2 *) |
| Point2 | UT2D_pt_obj2 (ObjG2 *obj1) |
| void | UT2D_ln_ptpt (Line2 *, Point2 *, Point2 *) |
| void | UT2D_ln_ptvc (Line2 *, Point2 *, Vector2 *) |
| void | UT2D_ln_ln3 (Line2 *ln2, Line *ln3) |
| void | UT2D_ln_inv (Line2 *ln1) |
| void | UT2D_ln_4db (Line2 *ln2, double xs, double ys, double xe, double ye) |
| Line2 | UT2D_ln_obj2 (ObjG2 *) |
| int | UT2D_lncoe_ln (double *k, double *d, Line2 *ln) |
| int | UT2D_ln_pts_dmax (Line2 *ln, int np, Point2 *ptab, double tol) |
| int | UT2D_comp2vc (Vector2 *, Vector2 *, double) |
| int | UT2D_comp2vc_p (Vector2 *, Vector2 *, double) |
| int | UT2D_ckvc_in2vc (Vector *v1, Vector *v2, Vector *v3) |
| int | UT2D_2parvc_3vc (double *, double *, Vector2 *, Vector2 *, Vector2 *) |
| void | UT2D_vc_2db (Vector2 *, double, double) |
| void | UT2D_vc_angr (Vector2 *, double) |
| void | UT2D_vc_angrlen (Vector2 *, double, double) |
| void | UT2D_vc_2pt (Vector2 *, Point2 *, Point2 *) |
| void | UT2D_vc_2pt3 (Vector2 *vc, Point *p1, Point *p2) |
| int | UT2D_vc_2pt3_bp (Vector2 *vo, Point *p1, Point *p2, int bp) |
| void | UT2D_vc_2ptlen (Vector2 *, Point2 *, Point2 *, double) |
| void | UT2D_vc_ln (Vector2 *, Line2 *) |
| void | UT2D_vc_invert (Vector2 *, Vector2 *) |
| int | UT3D_vc_Zup (Vector *v2, Vector *v1) |
| void | UT2D_vc_perpvc (Vector2 *, Vector2 *) |
| void | UT2D_vc_perp2pt (Vector2 *, Point2 *, Point2 *) |
| void | UT2D_vc_normalize (Vector2 *, Vector2 *) |
| void | UT2D_vc_setLength (Vector2 *, Vector2 *, double) |
| void | UT2D_vc_mid2vc (Vector2 *, Vector2 *, Vector2 *) |
| void | UT2D_vc_merge2vc (Vector2 *vm, Vector2 *v1, Vector2 *v2) |
| void | UT2D_vc_rotangr (Vector2 *, Vector2 *, double) |
| void | UT2D_vc_travcm2 (Vector2 *vo, Mat_3x2 mata, Vector2 *vi) |
| double | UT2D_angr_ciSec (double hc, double radc) |
| double | UT2D_len_ciSec (double hSec, double rCi) |
| double | UT2D_len_cia (double rad, double ango) |
| double | UT2D_len_cir (double *angOpe, Point2 *pa, Point2 *pe, Point2 *pc, double rad_in) |
| int | UT2D_compPtOnAc (double, double, double, int) |
| Circ2 | UT2D_ci_obj2 (ObjG2 *) |
| int | UT2D_ci_ptrd (Circ2 *ci, Point2 *ptc, double rdc) |
| int | UT2D_ci_ci3 (Circ2 *ci2, Circ *ci3) |
| int | UT2D_ci_2vc2ptrd (Point2 *, Point2 *, Vector2 *, Point2 *, Vector2 *, double) |
| int | UT2D_ci_ciptvcrd (Point2 *, Point2 *, double, int, Point2 *, Vector2 *, double) |
| int | UT2D_ci_ptvcpt (Point2 *, double *, Point2 *, Vector2 *, Point2 *) |
| int | UT2D_obj_obj3 (ObjGX *oo, ObjGX *oi, Memspc *memSeg) |
| ObjG2 | UT2D_obj_pt3 (Point *) |
| ObjG2 | UT2D_obj_ln3 (Line *) |
| ObjG2 | UT2D_obj_ci2 (Circ2 *) |
| ObjG2 | UT2D_obj_ci3 (Circ *) |
| ObjG2 | UT2D_obj_cv3 (Curv *) |
| int | UT2D_void_obj2 (void *memObj, unsigned long *oSiz, ObjG2 *og2) |
| void | UT2D_cv_ci360 (Point2 *cv, int ptNr, double rd, Point2 *ptCen) |
| int | UT2D_cv_ln (Point2 *cv, int ptAnz, Point2 *p1, Point2 *p2) |
| int | UT2D_npt_ci (Point2 *pa, int pNr, Circ2 *ci1) |
| int | UT2D_cv_ci (Point2[], int *, Point2 *, Point2 *, Point2 *, int) |
| int | UT2D_cv3_linear (int *pNr, Point *pTab, double tol) |
| int | UT2D_srar_polc (double *aro, int ptNr, Point2 *pa) |
| void | UT2D_m2_load (Mat_3x2, Vector2 *, Point2 *) |
| void | UT2D_m2_loadtravcm2 (Mat_3x2 ma, Vector2 *vx, Vector2 *vy, Vector2 *vt) |
| int | UT2D_m2_invtravcm2 (Mat_3x2 im1, Mat_3x2 m1) |
| void | UT2D_m2_init_rot (Mat_3x2 ma, double angle, Point2 *cen) |
| int | UT3D_stru_dump (int typ, void *data, char *txt,...) |
| double | UT3D_len_vc (Vector *) |
| double | UT3D_lenq_vc (Vector *) |
| int | UT3D_bplen_vc (double *lnv, Vector *vc1) |
| double | UT3D_lenB_2pt (Point *p1, Point *p2) |
| double | UT3D_len_2pt (Point *, Point *) |
| double | UT3D_lenq_PtPt (Point *p1, Point *p2) |
| int | UT3D_lenq_PtLn (double *lenq, Point *p, Point *p1, Point *p2) |
| double | UT3D_len_ln (Line *) |
| double | UT3D_len_ci (Circ *ci1) |
| double | UT3D_slen_3pt (Point *pt, Point *p1, Point *p2) |
| double | UT3D_slen_projvcvc (Vector *vc1, Vector *vc2) |
| double | UT3D_slenq_projvcvc (Vector *vc1, Vector *vc2) |
| double | UT3D_slenq_2ptvc (Point *p1, Point *p2, Vector *vc) |
| double | UT3D_nlen_projvcvc (Vector *vc1, Vector *vc2) |
| double | UT3D_slen_2ptvc (Point *p1, Point *p2, Vector *vc) |
| double | UT3D_slen_ptpl (Point *pt, Plane *pl) |
| double | UT3D_nlen_2ptvc (Point *p1, Point *pv, Vector *vc) |
| double | UT3D_nlen_3pt (Point *p1, Point *p2, Point *p3) |
| int | UT3D_parpt_objpt (double *po, Point *pti, int oTyp, void *oDat) |
| int | UT3D_parpt_3pt (double *pl, Point *ptx, Point *pl1, Point *pl2) |
| int | UT3D_parpt_ptvc (double *pl, Point *ptx, Point *pt1, Vector *vc1) |
| double | UT3D_parpt_lnbp (Point *pti, Line *ln1, int bp) |
| double | UT3D_parpt_cipt (Point *pti, Circ *ci1) |
| int | UT3D_pt_ck_npt (Point *p0, Point *pTab, int pNr, double tol) |
| int | UT3D_ipt_cknear_npt (Point *p0, Point *ptTab, int ptNr) |
| int | UT3D_ipt_ckfar_npt (Point *p0, Point *ptTab, int ptNr) |
| int | UT3D_ipt_cknearn_npt (Point *p0, Point *ptTab, int ptNr, int distNr) |
| int | UT3D_ipt2_nptvc (Point *pt1, Point *pt2, int mode, Point *pta, int iNr, Vector *vc) |
| int | UT3D_pt_ck_onel (Point *pt, CurvElli *el) |
| int | UT3D_pt_ck_ptvc (Point *pt, Point *pl, Vector *vl, double tol) |
| int | UT3D_pt_ck_2pt (Point *pt, Point *pl1, Point *pl2, double tol) |
| int | UT3D_pt_ck_onLine (Point *p1, Point *p2, Point *p3, double tol) |
| int | UT3D_pt_ck_inLine (Point *p1, Point *p2, Point *p3, double tol) |
| int | UT3D_pt_ck_perp2pt (Point *p1, Point *p2, Point *p3, double *tol) |
| int | UT3D_pt_ck_on_pta (Point *pTab, int ptNr, Point *pt1, double tol) |
| int | UT3D_pt_ck_in2pt (Point *p1, Point *p2, Point *p3, double tol) |
| int | UT3D_pt_ck_inCirc (Circ *ci1, Point *pt1, double tol) |
| int | UT3D_pt_ck_inSph (Point *pt, Point *ps, double rs) |
| void | UT3D_swap2pt (Point *p1, Point *p2) |
| int | UT3D_comp4pt (Point *p1a, Point *p1e, Point *p2a, Point *p2e, double tol) |
| int | UT3D_compptpl (Point *, Plane *) |
| Point | UT3D_pt_pt2 (Point2 *) |
| Point | UT3D_pt_pt2z (Point2 *pt20, double zVal) |
| void | UT3D_pt_3db (Point *, double, double, double) |
| void | UT3D_pt_vc (Point *, Vector *) |
| void | UT3D_pt_txt (Point *, char *) |
| void | UT3D_pt_mid2pt (Point *, Point *, Point *) |
| int | UT3D_pt_mid_pta (Point *pto, Point *pTab, int ptNr) |
| void | UT3D_pt_midci (Point *, Circ *) |
| void | UT3D_pt_opp2pt (Point *, Point *, Point *) |
| int | UT3D_pt_oppptptvc (Point *po, Point *pi, Point *pl, Vector *vl) |
| int | UT3D_2pt_oppptvclen (Point *, Point *, Point *, Vector *, double) |
| void | UT3D_pt_addpt (Point *, Point *) |
| void | UT3D_pt_add2pt (Point *, Point *, Point *) |
| void | UT3D_pt_traptvclen (Point *po, Point *pi, Vector *vc, double dist) |
| void | UT3D_pt_traptvc1len (Point *po, Point *pi, Vector *vc, double dist) |
| void | UT3D_pt_trapt2vc (Point *po, Point *pi, Vector *vc1, Vector *vc2) |
| void | UT3D_pt_trapt2vc2len (Point *, Point *, Vector *, double, Vector *, double) |
| void | UT3D_pt_trapt3vc3len (Point *po, Point *pi, Vector *vx, double dx, Vector *vy, double dy, Vector *vz, double dz) |
| void | UT3D_pt_traptptlen (Point *po, Point *pi, Point *pDir, double lenv) |
| void | UT3D_pt_trapt2pt (Point *po, Point *pi, Point *p1, Point *p2) |
| int | UT3D_pt_tracirlen (Point *pto, Point *pti, Circ *cii, double clen) |
| int | UT3D_pt_rotptptangr (Point *pto, Point *ptc, Point *pti, double *ar) |
| void | UT3D_pt_rotptptvcangr (Point *pto, Point *pti, Point *ptc, Vector *vz, double angr) |
| int | UT3D_pt_rotptm3 (Point *p2, Point *p1, Mat_4x3 ma) |
| int | UT3D_pt_rotciangr (Point *pto, double angr, Circ *ci1) |
| int | UT3D_pt_projpt2pt (Point *pp, double *len, Point *pt, Point *p1, Point *p2) |
| int | UT3D_pt_projptln (Point *, double *, Point *, Line *) |
| int | UT3D_pt_projptci (Point *pto, Point *pt1, Circ *ci1) |
| int | UT3D_pt_projptptvc (Point *pp, double *len, Point *pt, Point *pl, Vector *vl) |
| int | UT3D_pt_projptel (int *numpe, Point *pe, CurvElli *ell, Point *pt) |
| int | UT3D_pt_projptbspl (int *nxp, Point *ptab, double *ttab, Memspc *memSeg1, CurvBSpl *bspl, Point *pt) |
| int | UT3D_pt_projptptnvc (Point *po, Point *pi, Point *plo, Vector *plz) |
| void | UT3D_pt_projptpl (Point *, Plane *, Point *) |
| int | UT3D_pt_int2pt2vc (Point *ip1, Point *ip2, double *dist, Point *ptu, Vector *vcu, Point *ptv, Vector *vcv) |
| int | UT3D_pt_intptvcplx (Point *px, Point *pl, Vector *vl, double plx) |
| int | UT3D_pt_intptvcply (Point *px, Point *pl, Vector *vl, double ply) |
| int | UT3D_pt_intptvcplz (Point *px, Point *pl, Vector *vl, double plz) |
| int | UT3D_pt_intptvcln (Point *ip1, Point *ip2, double *dist, Point *pt1, Vector *vc1, Line *ln2) |
| int | UT3D_pt_intptvcxpln (Point *pti, Point *ptl, Point *ptpl, Vector *vcpl) |
| int | UT3D_pt_intptvcypln (Point *pti, Point *ptl, Point *ptpl, Vector *vcpl) |
| int | UT3D_pt_intptvczpln (Point *pti, Point *ptl, Point *ptpl, Vector *vcpl) |
| int | UT3D_pt_intptvcsph (Point *pa, Point *pl, Vector *vl, Point *ps, double rs) |
| int | UT3D_pt_int2ln (Point *, Point *, double *, Line *, Line *) |
| int | UT3D_pt_intperp2ln (Point *po, Point *p1, Vector *v1, Point *p2, Vector *v2) |
| int | UT3D_pt_intlnci__ (int *np, Point xp[], Line *ln, Circ *ci1) |
| int | UT3D_pt_intlnci_p (int *np, Point xp[], Line *ln, Circ *ci1) |
| int | UT3D_pt_intlnsph (Line *ln1, Point *ps, double rs) |
| int | UT3D_pt_intcici (Point pa[], Circ *ci1, int ci1Lim, Circ *ci2, int ci2Lim) |
| int | UT3D_pt_intplnln (Point *ip, double *dist, Plane *pl, Line *ln) |
| int | UT3D_pt_intlnpl (Point *, Plane *, Line *) |
| int | UT3D_pt_intlnpl1 (Point *, double *, Point *, Point *, double, double) |
| int | UT3D_pt_intptvcpln (Point *pti, Point *ptl, Vector *vcl, Point *ptpl, Vector *vcpl) |
| int | UT3D_pt_intplnci (Point pa[], Plane *pl1, Circ *ci1, int ciLim) |
| int | UT3D_pt_intcidpln (int *np, Point xp[], Point *pc, Point *p1, Vector *vz, double dx) |
| int | UT3D_pt_intptvcpl_ (Point *, Plane *, Point *, Vector *) |
| int | UT3D_pt_intlnel__ (int *np, Point xp[], Line *ln, CurvElli *el) |
| int | UT3D_pt_intlnel_p (int *np, Point xp[], Line *ln, CurvElli *el) |
| int | UT3D_pt_ipl_2ptpt2 (Point *pi3, Point *p1, Point *p2, Point2 *pi2) |
| int | UT3D_pt_mirptpl (Point *pto, Point *pti, Plane *pln) |
| int | UT3D_pt_mirptln (Point *pto, Point *pti, Line *ln) |
| int | UT3D_pt_tangptci (Point *po1, Point *po2, Point *pt1, Circ *ci1) |
| int | UT3D_pt_elfoc (Point *fp1, Point *fp2, CurvElli *el) |
| int | UT3D_pt_evparln (Point *pto, double lpar, Line *ln1) |
| int | UT3D_pt_evparci (Point *pto, double lpar, Circ *ci1) |
| int | UT3D_pt_m3 (Point *pto, Mat_4x3 ma) |
| void | UT2D_pt_traptm3 (Point2 *p2, Mat_4x3 mata, Point2 *p1) |
| void | UT3D_pt_traptm3 (Point *, Mat_4x3, Point *) |
| void | UT3D_pt_traptm4 (Point *p2, Mat_4x4 ma, Point *p1) |
| int | UT2D_ptvc_ck_int2pt (int mode, Point2 *p1s, Vector2 *v1, Point2 *p2s, Point2 *p2e) |
| int | UT3D_ptvc_int2pl (Point *pt, Vector *vc, Plane *pl1, Plane *pl2) |
| int | UT3D_ptvc_int2pln (Point *pti, Vector *vci, Point *pl1pt, Vector *pl1vz, Point *pl2pt, Vector *pl2vz) |
| int | UT3D_ptvc_ox (Point *pta, Vector *vca, ObjGX *oxi) |
| double | UT3D_angr_3pt (Point *p1, Point *pc, Point *p2) |
| double | UT3D_angr_2vc (Vector *, Vector *) |
| double | UT3D_angr_3vc (Vector *vz, Vector *v1, Vector *v2) |
| double | UT3D_angr_ci (Circ *ci1) |
| int | UT3D_2angr_vc (double *az, double *ay, Vector *vc1) |
| int | UT3D_atan_vcpl (double *kvc, Vector *vci, Plane *pli) |
| int | UT3D_compvc0 (Vector *v1, double tol) |
| int | UT3D_comp2vc_d (Vector *, Vector *, double) |
| int | UT3D_comp2vc_p (Vector *, Vector *, double) |
| void | UT3D_vc_pt (Vector *, Point *) |
| int | UT3D_vc_ck_parpl (Vector *vci, Plane *pli, double tol) |
| int | UT3D_vc_ckperp_2vc1 (Vector *vc1, Vector *vc2, double tol) |
| int | UT3D_vc_ck_std (Vector *vc1) |
| int | UT3D_parvc_2vcbp (double *dl, int mainPln, Vector *v1, Vector *v2) |
| int | UT3D_2parvc_3vcbp (double *, double *, int, Vector *, Vector *, Vector *) |
| void | UT3D_vc_txt (Vector *vc, char *txt) |
| void | UT3D_vc_2ptlen (Vector *, Point *, Point *, double) |
| void | UT3D_vc_angr (Vector *vc, double angr) |
| void | UT3D_vc_2angr (Vector *, double, double) |
| void | UT3D_vc_2vc (Vector *, Vector *, Vector *) |
| void | UT3D_vc_ln (Vector *, Line *) |
| int | UT3D_vc_bp (Vector *vn, int bp) |
| void | UT3D_vc_invert (Vector *, Vector *) |
| void | UT3D_vc_perp1vc (Vector *vp, Vector *vi) |
| void | UT3D_vc_perp2vc (Vector *, Vector *, Vector *) |
| int | UT3D_vc_perpvc2pt (Vector *vp, Vector *vx, Point *pc, Point *py) |
| int | UT3D_vc_perp3pt (Vector *vp, Point *ptc, Point *ptx, Point *pty) |
| int | UT3D_vc_perp4pt (Vector *vp, Point *p1, Point *p2, Point *p3, Point *p4) |
| void | UT3D_vc_perpTria (Vector *vn, Triangle *tri) |
| void | UT3D_vc_perpvcplXY (Vector *, Vector *) |
| int | UT3D_vc_perppta (Vector *vcn, int pNr, Point *pa) |
| void | UT3D_vc_normalize (Vector *, Vector *) |
| void | UT3D_vc_setLength (Vector *, Vector *, double) |
| int | UT3D_vc_setLenLen (Vector *vco, Vector *vci, double newLen, double actLen) |
| void | UT3D_vc_tangci (Vector *vs, Circ *ci1, double u) |
| int | UT3D_vc_tangcipt (Vector *vt, Point *p1, Circ *ci) |
| int | UT3D_vc_rotangr (Vector *vco, Vector *vci, double *ar) |
| void | UT3D_vc_rot3angr (Vector *, Vector *, double, double, double) |
| int | UT3D_vc_rotvcvcangr (Vector *vo, Vector *va, Vector *vi, double angr) |
| int | UT3D_vc_projvcvc (Vector *v3, Vector *v1, Vector *v2) |
| int | UT3D_vc_projvc2vc (Vector *vo, Vector *vi, Vector *v1, Vector *v2) |
| int | UT3D_vc_projvcnvc (Vector *vo, Vector *vi, Vector *vz) |
| void | UT3D_vc_projvcpl (Vector *, Plane *, Vector *) |
| int | UT3D_vc_mirvcpl (Vector *vco, Vector *vci, Plane *pln) |
| int | UT3D_vc_mirvcln (Vector *vco, Vector *vci, Line *ln) |
| void | UT3D_vc_travcm3 (Vector *b, Mat_4x3 ma, Vector *a) |
| void | UT3D_vc_travcm4 (Vector *b, Mat_4x4 ma, Vector *a) |
| int | UT3D_comp2ln (Line *pa1, Line *pa2, double tol) |
| int | UT3D_ln_ck_on_ln (Point *, Point *, Point *, Point *, Point *, Point *, double tol) |
| int | UT3D_ln_ck_parpl (double *dist, Line *ln, Plane *pl, double tol) |
| void | UT3D_ln_6db (Line *, double, double, double, double, double, double) |
| void | UT3D_ln_2pt2 (Line *ln1, Point2 *pta, Point2 *pte) |
| int | UT3D_ln_int2pl (Line *ln, Plane *pl1, Plane *pl2) |
| int | UT3D_ln_tangcici (Line *ln1, Circ *ci1, Circ *ci2, int sNr) |
| int | UT3D_ln_parl2ln (Point *, Point *, Point *, Point *, Point *, Point *) |
| int | UT3D_ln_pts_dmax (Line *ln, int np, Point *ptab, double tol) |
| int | UT3D_ln_setLen (Line *lno, Point *pc, double lnlg, Line *lni) |
| void | UT3D_ln_inv (Line *ln1) |
| void | UT3D_ln_ln2 (Line *, Line2 *) |
| int | UT3D_rdc_3pt (double *rdc, Point *pp1, Point *pp2, Point *pp3) |
| int | UT3D_ck_ci180 (Circ *ci1) |
| int | UT3D_ck_ci360 (Circ *ci1) |
| int | UT3D_ci_cip1 (Circ *ci1, Point *p1) |
| int | UT3D_ci_ptvcr (Circ *ci1, Point *pc, Vector *vz, double rc) |
| int | UT3D_ci_pt2vcr (Circ *ci1, Point *pc, Vector *vz, Vector *vx, double rc) |
| int | UT3D_ci_cip2 (Circ *ci1, Point *p2) |
| int | UT3D_ci_cip3 (Circ *ci1, Point *p1, Point *p2) |
| int | UT3D_ci_ciangr (Circ *ci, double ao2) |
| void | UT3D_ci_setangr (Circ *ci1) |
| int | UT3D_ci_ptptvcangr (Circ *ci, Point *pc, Point *p1, Vector *vz, double ao) |
| int | UT3D_ci_ptptvcrd (Circ *ci, Point *p1, Point *p2, double rd, Vector *vz, int siz) |
| int | UT3D_ci_cipt180 (Circ *ci1, Point *p1) |
| int | UT3D_ci_cipt360 (Circ *ci1, Point *p1) |
| int | UT3D_ci_pcvzpt180 (Circ *ci1, Point *pc, Vector *vz, Point *p1, int dreh) |
| int | UT3D_ptNr_ci (Circ *ci1, double tol) |
| int | UT3D_ci_inv1 (Circ *ci1) |
| int | UT3D_ci_inv2 (Circ *ci1) |
| int | UT3D_ci_inv3 (Circ *ci1) |
| Circ | UT3D_ci_ci2 (Circ2 *) |
| Circ | UT3D_ci_obj2 (ObjG2 *) |
| Circ | UT3D_ci_obj (ObjG *ci_in) |
| int | UT3D_ci_ptvcrd (Circ *ci, Point *ps, Vector *vs, double rd, Vector *vz, double a1) |
| int | UT3D_ci_2ptvcrd (Circ *cia, Point *pp1, Point *pp2, Vector *vz, double rdc) |
| int | UT3D_ci_3pt (Circ *cpo, Point *pp1, Point *pp2, Point *pp3) |
| int | UT3D_civz_ci (Circ *ci1) |
| int | UT3D_ci_ptptrd (Circ ca[], Point *pt1, Point *pt2, double radi) |
| int | UT3D_ci_lnptrd (Circ ca[], Line *ln1, Point *pt1, Vector *vz, double rdc) |
| int | UT3D_ci_ciptrd (Circ ca[], Circ *ci1, Point *pt1, double rdc) |
| int | UT3D_ci_2lnrd (Circ ca[], Line *ln1, Line *ln2, double rdc, int) |
| int | UT3D_ci_cicird (Circ ca[], Circ *ci1, Circ *ci2, double rdc, int) |
| int | UT3D_ci_lncird (Circ ca[], Line *ln1, Circ *ci1, double rdc, int) |
| int | UT3D_ci_intplsph (Circ *cio, Plane *pli, Sphere *spi) |
| int | UT3D_ci_ptrd2vc2angr (Circ *ci, Point *pc, double rd, Vector *vz, Vector *vx, double a1, double a2) |
| int | UT3D_ci_ptvcpt2angr (Circ *ci, Point *pc, Point *p1, Vector *vz, double a1, double a2) |
| int | UT3D_ck_el360 (CurvElli *el1) |
| int | UT3D_el_elpt180 (CurvElli *el1, Point *p1) |
| double | UT3D_angr_elpt (Point *pti, Point *ptc, Vector *va, Vector *vb) |
| int | UT2D_pt_elangd (Point2 *pto, double lx, double ly, double angr) |
| int | UT3D_pt_elangd (Point *pto, Point *ptc, Vector *va, Vector *vb, double angr) |
| int | UT3D_el_pt2vc2a (CurvElli *el, Point *ptc, Vector *vcx, Vector *vcy, double a1, double a2, int idir) |
| int | UT3D_el_projcipl (CurvElli *el, Plane *pl, Circ *ci) |
| int | UT3D_el_projelpl (CurvElli *elo, Plane *pl, CurvElli *eli) |
| int | UT3D_el_elcoe (CurvElli *, polcoeff_d5 *, Point2 *pa, Point2 *pe, double zt) |
| int | UT3D_elcoe_el (polcoeff_d5 *, CurvElli *) |
| int | UT3D_pta_ck_planar (int pNr, Point *pTab, Point *pPln, Vector *vc) |
| int | UT3D_rMin_pta (double *rMin, int pNr, Point *pTab) |
| int | UT3D_sr_polc (int ptNr, Point *pa, Vector *vcn, int plMain) |
| int | UT3D_pta_dbo (Point **pTab, int *pNr, int typ, long ind, double tol) |
| Curv | UT3D_cv_obj2 (ObjG2 *) |
| void | UT3D_cv_ln (Point *cv, int *ptAnz, Point *p1, Point *p2) |
| int | UT3D_npt_ci (Point *pa, int pNr, Circ *ci1) |
| void | UT3D_cv_ci (Point cv[], int *ptanz, Circ *ci1, int ptmax, double tol) |
| int | UT3D_cv_ell (Point cv[], int *numpt, CurvElli *el, int ptmax, double stol) |
| int | UT3D_cv_delia (int *pNr, Point *pTab, char *ptStat) |
| int | UT3D_cv3_linear (int *pNr, Point *pTab, double tol) |
| int | UT3D_obj_dump (ObjG *el) |
| ObjG | UT3D_obj_ln (Line *) |
| ObjG | UT3D_obj_ci (Circ *) |
| int | UT3D_bp_2pt (Point *pt1, Point *pt2) |
| int | UT3D_bp_vc_ (Vector *) |
| int | UT3D_bp_vcz (Vector *) |
| void | UT3D_pl_XYZ (Plane *pl1) |
| int | UT3D_pl_bpdb (Plane *plo, int bp, double dbc) |
| int | UT3D_pl_3pt (Plane *, Point *, Point *, Point *) |
| void | UT3D_pl_ptvcvc (Plane *pl1, Point *po, Vector *vx, Vector *vz) |
| void | UT3D_pl_pt2vc (Plane *, Point *, Vector *, Vector *) |
| int | UT3D_pl_ptvc (Plane *, Point *, Vector *) |
| void | UT3D_pl_ptvcpt (Plane *pl1, Point *po, Vector *vz, Point *ptx) |
| int | UT3D_pl_ln (Plane *pln, Line *lna) |
| void | UT3D_pl_2ln (Plane *pl1, Line *ln1, Line *ln2) |
| int | UT3D_pl_ci (Plane *pl1, Circ *ci1) |
| int | UT3D_pl_nobj (Plane *pl1, int oNr, ObjGX *oTab) |
| void | UT3D_pl_invert (Plane *pl) |
| int | UT3D_pl_rotpt (Plane *plo, Plane *pli, Point *ptx) |
| void | UT3D_pl_ptpl (Plane *pl, Point *pt1) |
| int | UT3D_pl_plcoe (Plane *pl, polcoeff_d3 *co) |
| int | UT3D_plcoe_pl (polcoeff_d3 *co, Plane *pl) |
| void | UT3D_pl_p (Plane *pl) |
| double | UT3D_plg_lvTab (double *lvTab, Point *pta, int ptNr) |
| int | UT3D_pta_plg (int *ptNr, Point *pta, CurvPoly *plg) |
| int | UT2D_box_ini0 (Point2 *pt1, Point2 *pt2) |
| int | UT2D_box_extend (Point2 *pb1, Point2 *pb2, Point2 *pt1) |
| int | UT2D_rect_pts (Point2 *pmin, Point2 *pmax, int nump, Point2 *ptab) |
| int | UT3D_cv_boxxy (Point *pb1, double x1, double x2, double y1, double y2) |
| int | UT3D_box_extend (Point *pb1, Point *pb2, Point *pt1) |
| int | UT3D_box_2pt (Point *pb1, Point *pb2, Point *pt1, Point *pt2) |
| int | UT3D_box_2pttol (Point *pb1, Point *pb2, Point *pt1, Point *pt2, double tol) |
| int | UT3D_box_pts (Point *pmin, Point *pmax, int nump, Point *ptab) |
| int | UT3D_box_tria (Point *pb1, Point *pb2, Triangle *tr, double tol) |
| int | UT3D_box_addTol (Point *pb1, Point *pb2, double tol) |
| int | UT3D_ck_ptInBox (Point *p1, Point *p2, Point *px) |
| int | UT3D_ckBoxinBox1 (Point *p1, Point *p2, Point *p3, Point *p4) |
| int | UT3D_box_ck_intLn (Line *ln, Point *pmin, Point *pmax, double tol) |
| int | UT3D_box_ck_intpl (Plane *pln, Point *p1, Point *p2, double tol) |
| int | UT3D_rbox_loadxy (Point *pb1, double x1, double x2, double y1, double y2) |
| int | UT3D_ptvc_intbox (Point *pl, Vector *vl, Point *bp1, Point *bp2) |
| int | UT3D_ln_intbox (Line *ln1, Point *bp1, Point *bp2) |
| void | UT3D_tria_pta_fac (Triangle *, Fac3 *, Point *) |
| int | UT3D_m3_inirot (Mat_4x3 ma, Point *pa, Vector *va, double angr) |
| void | UT3D_m3_loadpl (Mat_4x3, Plane *) |
| void | UT3D_m3_load (Mat_4x3, Vector *, Vector *, Vector *) |
| void | UT3D_m3_load_povxvy (Mat_4x3 ma, Point *ori, Vector *vx, Vector *vy) |
| void | UT3D_m3_load_povxvz (Mat_4x3 ma, Point *ori, Vector *vx, Vector *vz) |
| void | UT3D_m3_load_o (Mat_4x3, Point *) |
| int | UT3D_m3_invm3 (Mat_4x3, Mat_4x3) |
| void | UT3D_m3_multm3 (Mat_4x3 m3, Mat_4x3 m1, Mat_4x3 m2) |
| int | UT3D_m3_tram3m3 (Mat_4x3 m3, Mat_4x3 m1, Mat_4x3 m2) |
| void | UT3D_m4_init (Mat_4x4 ma) |
| void | UT3D_m4_init_ori (Mat_4x4 ma, double px, double py, double pz) |
| void | UT3D_m4_init_rot (Mat_4x4 ma, double angle, Vector *axis) |
| void | UT3D_m4_loadpl (Mat_4x4 m1, Plane *pl1) |
| void | UT3D_m4_load_o (Mat_4x4 ma, Point *ori) |
| void | UT3D_m4_addrot (Mat_4x4 mo, Mat_4x4 ma, Mat_4x4 mb) |
| void | UT3D_m4_addtra (Mat_4x4 ma, double px, double py, double pz) |
| double | UT3D_sbs_ck_planar (SurBSpl *su1) |
| double | UT3D_sru_ck_planar (ObjGX *ru1) |
Variables | |
| double | UT_TOL_pt |
| identical Points-tolerence | |
| double | UT_TOL_cv |
| max deviation from curve (distance analyticalCurve -> Curvepoint) | |
| double | UT_TOL_ln |
| max deviation of a point from a line | |
| double | UT_DISP_cv |
| max deviation from curve (distance analyticalCurve -> displayPolygon) | |
| double | UT_TOL_min0 |
| double | UT_TOL_min1 |
| double | UT_TOL_min2 |
| double | UT_TOL_PAR |
| tolerance for parallelism | |
| double | UT_TOL_Ang1 |
| tolerance for Angle 0.01 Grad | |
| const double | UT_VAL_MIN |
| const double | UT_VAL_MAX |
| const double | UT_DB_LEER |
| const double | UT_DB_NULL |
| const int | UT_INT_MAX |
| const int | UT_I2_MAX |
| const char | UT_CHR_NULL |
| const Point2 | UT2D_PT_NUL |
| const Point | UT3D_PT_NUL |
| const Vector2 | UT2D_VECTOR_NUL |
| const Vector2 | UT2D_VECTOR_X |
| const Vector2 | UT2D_VECTOR_Y |
| const Vector | UT3D_VECTOR_NUL |
| const Vector | UT3D_VECTOR_X |
| const Vector | UT3D_VECTOR_Y |
| const Vector | UT3D_VECTOR_Z |
| const Vector | UT3D_VECTOR_IX |
| const Vector | UT3D_VECTOR_IY |
| const Vector | UT3D_VECTOR_IZ |
| const Mat_3x3 | UT3D_MAT_3x3 |
| const Mat_4x3 | UT3D_MAT_4x3 |
| const Mat_4x4 | UT3D_MAT_4x4 |
Basic geometry definitions.
| #define RAD_360 6.2831853071795862319 |
360 Grad
| #define RAD_270 4.7123889803846896739 |
270 Grad
| #define RAD_225 3.92699081698724151736 |
225 Grad
| #define RAD_180 3.14159265358979323846 |
180 Grad
| #define RAD_135 2.3561944901923448368 |
135 Grad
| #define RAD_90 1.5707963267948965579 |
90 Grad
| #define RAD_60 1.0471975511965976313 |
60 Grad
| #define RAD_45 0.7853981633974482789 |
45 Grad
| #define RAD_30 0.5235987755982988156 |
30 Grad
| #define RAD_10 0.174532925199432954 |
10 Grad
| #define RAD_1 0.0174532925199432954 |
1 Grad
| #define RAD_01 0.0017453292519943295 |
0.1 Grad
| #define SR_3 1.7320508075688772 |
SQRT(3).
| #define SR_2 1.4142135623730951 |
SQRT(2).
| #define SR_PI 1.7724538509055159 |
SQRT(PI) = SQRT(RAD_180).
| #define CCW 1 |
counterclockwise
| #define CW -1 |
clockwise
| #define YES 0 |
FALSE.
| #define NO 1 |
TRUE.
| #define ON 0 |
FALSE.
| #define OFF 1 |
TRUE.
| #define LIMITED 0 |
| #define UNLIMITED 1 |
| #define Typ_Error 0 |
U0 = undefined.
types: nr = TYP_SIZ. See also xa_sele.h typText: TypTxtTab0
0- 49 lin.objs 3D, 2D. 50- 79 Surfaces 80- 89 Bodies 90-109 notes, images 110-119 temp objs 120-129 geom. attributes 130-149 geom. parameters 150-169 attributes 170-189 dataFormats (Int, matrix, Polynom..) 190-199 Text 200-209 containers 210-219 transformations 220-229 operators 230-249 modifiers 250-259 events 260-269 functions 270-279 function parameters
| #define Typ_VAR 1 |
V numer. variable.
| #define Typ_PT 2 |
P Point.
| #define Typ_LN 3 |
L Line.
| #define Typ_CI 4 |
C do not use; use Typ_AC.
| #define Typ_AC 5 |
C Circ.
| #define Typ_VC 6 |
D Vector.
| #define Typ_CV 7 |
S all curves.
| #define Typ_CVPOL 8 |
S CurvPoly.
| #define Typ_CVPSP3 9 |
S polynom_d3.
| #define Typ_CVBSP 10 |
S CurvBSpl.
| #define Typ_CVRBSP 11 |
S CurvRBSpl.
| #define Typ_CVCCV 12 |
S CurvCCV.
| #define Typ_CVELL 13 |
S CurvElli.
| #define Typ_CVBEZ 14 |
S CurvBez.
| #define Typ_CVRBEZ 15 |
S CurvRBez.
| #define Typ_CVCLOT 16 |
S ClothoidCurve (CurvClot).
| #define Typ_CVLNA 18 |
S array of lines (form=Typ_LN).
| #define Typ_SymRef 17 |
| #define Typ_Vertex 19 |
Vertex; point on existing object.
| #define Typ_lFig 20 |
Linear Obj; LN/CI/CV.
| #define Typ_EdgeLine 21 |
| #define Typ_PT2 22 |
P Point2.
| #define Typ_LN2 23 |
L Line2.
| #define Typ_AC2 24 |
C Circ2.
| #define Typ_CI2 25 |
C do not use; use Typ_AC2.
| #define Typ_VC2 26 |
D Vector2.
| #define Typ_CV2 27 |
S all 2D-curves.
| #define Typ_CVPOL2 28 |
S CurvPoly-2D.
| #define Typ_CVPSP2 29 |
S polynom_?
| #define Typ_CVBSP2 30 |
S CurvBSpl-2D.
| #define Typ_CVRBSP2 31 |
S CurvRBSpl-2D.
| #define Typ_CVCCV2 32 |
| #define Typ_CVELL2 33 |
S CurvElli-2D.
| #define Typ_CVBEZ2 34 |
S CurvBez2.
| #define Typ_SymRef2 35 |
| #define Typ_SUR 50 |
Surfaces.
A all surfaces
| #define Typ_SURCIR 51 |
tesselated fan
| #define Typ_SURSTRIP 52 |
tesselated strip
| #define Typ_SURRU 53 |
A Ruled Sur.
| #define Typ_SURRV 54 |
A Revolved Sur.
| #define Typ_SURBSP 55 |
A B_Spline_Surf SurBSpl.
| #define Typ_SURRBSP 56 |
A Rat.B_Spline Surf SurRBSpl.
| #define Typ_SURPLN 57 |
A Planar surf.
| #define Typ_SURCON 58 |
Conus (unused).
| #define Typ_SURTOR 59 |
Torus (unused).
| #define Typ_PLN 60 |
R plane/Refsys.
| #define Typ_SURTPS 62 |
A surface-trimmed-perforated-supported.
| #define Typ_SURMSH 63 |
A Mesh.
| #define Typ_SURPTAB 64 |
A surf from PTAB.
| #define Typ_SURHAT 65 |
A Hatch.
| #define Typ_QFac 67 |
Triangle;.
| #define Typ_GL_Sur 70 |
tesselated surface
| #define Typ_GL_PP 71 |
tesselated planar patch
| #define Typ_GL_CV 72 |
Polygon.
| #define Typ_SOL 80 |
bodies
B body (CON, TOR, ..)
| #define Typ_SPH 81 |
B sphere.
| #define Typ_CON 82 |
B Conus (Cylinder).
| #define Typ_TOR 83 |
B Torus.
| #define Typ_PRI 84 |
B Prism.
| #define Typ_Note 90 |
notes, images
GroupCode f Typ_ATXT|Typ_GTXT|Typ_Dimen..
| #define Typ_ATXT 91 |
N AText.
| #define Typ_GTXT 92 |
N GText.
| #define Typ_Dimen 93 |
N.
| #define Typ_Dim3 94 |
N.
| #define Typ_Tag 95 |
N Bitmap (Blocknote, Image ..).
| #define Typ_SymB 96 |
bitmap symbols: SYM_TRI_S SYM_STAR_S ..
| #define Typ_SymV 97 |
Vektorymbole: SYM_PLANE SYM_ARROW ..
| #define Typ_Texture 100 |
index to TexRef
| #define Typ_TEXB 101 |
Base-Texture TexBas.
| #define Typ_TEXR 102 |
Ref-Texture TexRef.
| #define Typ_TmpPT 110 |
temp objs
temporary Point
| #define Typ_TmpLN 111 |
temporary Line
| #define Typ_TmpVC 113 |
temporary Vector
| #define Typ_TmpSym 114 |
temporary Symbol
| #define Typ_TmpTRI 115 |
temporary triangle
| #define Typ_TmpPLN 116 |
temporary Plane
| #define Typ_EyePT 117 |
| #define Typ_Box 118 |
| #define Typ_Part 120 |
geom. attributes
| #define Typ_Group 121 |
U ObjDB DB-Objects (union-group).
| #define Typ_SubModel 122 |
M - basicModel.
| #define Typ_Model 123 |
M - ModelReference ModelRef.
| #define Typ_Mock 124 |
| #define Typ_Ditto 125 |
| #define Typ_Joint 126 |
connection, exported;
| #define Typ_Val 130 |
geom. parameters TYP_IS_GEOMPAR
double-Value
| #define Typ_ValX 131 |
X-coord.
| #define Typ_ValY 132 |
Y-coord.
| #define Typ_ValZ 133 |
Z-coord.
| #define Typ_XVal 134 |
X-distance.
| #define Typ_YVal 135 |
Y-distance.
| #define Typ_ZVal 136 |
Z-distance.
| #define Typ_Angle 137 |
Angle (in degree).
| #define Typ_Rad 138 |
Radius.
| #define Typ_Dist 139 |
distance
| #define Typ_Par1 140 |
Parameter 0-1; for knotvals use Typ_Val.
| #define Typ_UVal 141 |
| #define Typ_VVal 142 |
| #define Typ_AngN 143 |
| #define Typ_AngP 144 |
| #define Typ_RadISO 145 |
| #define Typ_Conic 146 |
| #define Typ_Typ 150 |
attributes
form of ObjGX-Record defines Typ
| #define Typ_Subtyp 151 |
| #define Typ_cmdNCsub 152 |
| #define Typ_Address 153 |
form of ObjGX-Record defines dataPosition
| #define Typ_Size 154 |
recordSize for following record
| #define Typ_Index 155 |
int or long
| #define Typ_Name 156 |
| #define Typ_Color 157 |
| #define Typ_Ltyp 158 |
line type
| #define Typ_Thick 159 |
line thickness
| #define Typ_G_Att 160 |
G.
| #define Typ_Activ 161 |
I = Interactivity.
| #define Typ_Layer 162 |
| #define Typ_APPOBJ 163 |
| #define Typ_apDat 164 |
application-data Typ_APPOBJ
| #define Typ_Tool 165 |
| #define Typ_Data 170 |
dataFormats (Int, matrix, Polynom..)
binary data
| #define Typ_Int1 171 |
8 bit (char)
| #define Typ_Int2 172 |
16 bit (short)
| #define Typ_Int4 173 |
32 bit (int, long)
| #define Typ_Float4 174 |
32 bit (float)
| #define Typ_Float8 175 |
64 bit (double)
| #define Typ_Polynom_ 176 |
| #define Typ_Polynom1 177 |
| #define Typ_Polynom3 178 |
| #define Typ_polynom_d3 179 |
| #define Typ_M3x2 181 |
Mat_3x2.
| #define Typ_M3x3 182 |
Mat_3x3.
| #define Typ_M4x3 183 |
Mat_4x3.
| #define Typ_M4x4 184 |
Mat_4x4.
| #define Typ_Txt 190 |
text
$ ohne ", normal mit , begrenzt f. $20=
| #define Typ_String 191 |
durch " begrenzt
| #define Typ_StrDel 192 |
StringDelimiter "\" Fortsetzungszeile.
| #define Typ_StrDel1 193 |
StringDelimiter 1 "|".
| #define Typ_FncNam 194 |
| #define TYP_FilNam 195 |
filename
| #define Typ_CtlgPart 196 |
catalogpart
| #define Typ_Memspc 200 |
containers
Memspc
| #define Typ_MemTab 201 |
MemTab ../ut/ut_memTab.h.
| #define Typ_ObjRange 202 |
| #define Typ_ObjSRC 203 |
| #define Typ_ObjGX 204 |
| #define Typ_ObjG2 205 |
deprec
| #define Typ_ObjG 206 |
deprec
| #define Typ_ObjDB 207 |
| #define Typ_Tra 210 |
transformations
all transformations
| #define Typ_TraTra 211 |
Translation dzt unused; Typ_VC used.
| #define Typ_TraRot 212 |
Rotation TraRot.
| #define Typ_TraMat 213 |
Matrixtransformation.
| #define Typ_ope_eq 220 |
operators
operator =
| #define Typ_ope_ne 221 |
operator !=
| #define Typ_ope_lt 222 |
operator <
| #define Typ_ope_gt 223 |
operator >
| #define Typ_ope_ge 224 |
operator >=
| #define Typ_ope_le 225 |
operator <=
| #define Typ_ope_and 226 |
operator &
| #define Typ_ope_or 227 |
operator |
| #define Typ_modif 230 |
modifiers TYP_IS_MOD
Modifier MOD
| #define Typ_mod1 231 |
Modifier; Value depends.
| #define Typ_mod2 232 |
Modifier; Value depends.
| #define Typ_modCWCCW 233 |
Modifier; CW CCW.
| #define Typ_modREV 234 |
Modifier; Reverse.
| #define Typ_modCX 235 |
Modifier ACROSS (V-direction).
| #define Typ_modCTRL 236 |
| #define Typ_modPERP 237 |
perpendicular (right angled; default = parall)
| #define Typ_modPARL 238 |
parallel (U-direction)
| #define Typ_modHIX 239 |
| #define Typ_modLOX 240 |
| #define Typ_modHIY 241 |
| #define Typ_modLOY 242 |
| #define Typ_modHIZ 243 |
| #define Typ_modLOZ 244 |
| #define Typ_modCCW 245 |
| #define Typ_modCW 246 |
| #define Typ_modIN 247 |
| #define Typ_modOUT 248 |
| #define Typ_modAux 249 |
Modifier; on|off; text=last infoWord.
| #define TYP_EvMouseL 250 |
events DO NOT USE - replaced by TYP_Event* ../ut/types_gui.h
event left mousebutton
| #define TYP_EvMouseM 251 |
event mid mousebutton
| #define TYP_EvMouseR 252 |
event right mousebutton
| #define TYP_EvMouse2L 253 |
event doubleclick
| #define TYP_FuncInit 260 |
functions see also UI_Func* ../ut/types_gui.h
function init
| #define TYP_FuncInit1 261 |
function
| #define TYP_FuncMod 262 |
function modify
| #define TYP_FuncAdd 263 |
function add
| #define TYP_FuncDel 264 |
function delete
| #define TYP_FuncEnd 265 |
function end
| #define TYP_FuncExit 266 |
function exit
| #define TYP_SIZ 270 |
nr of defined types
| #define Typ_ALL 270 |
function parameters
| #define Typ_Done 271 |
| #define Typ_NULL 272 |
nothing, empty; Typ_unknown
| #define Typ_last 273 |
| #define TYP_OpmPlus 280 |
math.operators
| #define TYP_OpmMinus 281 |
| #define TYP_OpmMult 282 |
| #define TYP_OpmDiv 283 |
| #define Typ_FcmSQRT 290 |
math.functions
| #define Typ_FcmSIN 291 |
| #define Typ_FcmCOS 292 |
| #define Typ_FcmTAN 293 |
| #define Typ_FcmASIN 294 |
| #define Typ_FcmACOS 295 |
| #define Typ_FcmATAN 296 |
| #define Typ_FcmABS 297 |
| #define Typ_FcmFIX 298 |
| #define Typ_FcmRND 299 |
| #define BCKPLN_XY 2 |
Z-Vec BCKVEC_Z.
| #define BCKPLN_XZ 1 |
Y-Vec BCKVEC_Y.
| #define BCKPLN_YZ 0 |
X-Vec BCKVEC_X.
| #define BCKVEC_Z 2 |
Z-Vec BCKPLN_XY.
| #define BCKVEC_Y 1 |
Y-Vec BCKPLN_XZ.
| #define BCKVEC_X 0 |
X-Vec BCKPLN_YZ.
| #define GL_TRIANGLE_NPFAN 16 |
non planar fan (GL_TRIANGLE_FAN = planar)
| #define Mtyp_Gcad 0 |
| #define Mtyp_DXF 1 |
| #define Mtyp_Iges 2 |
| #define Mtyp_Step 3 |
| #define Mtyp_3DS 4 |
| #define Mtyp_LWO 5 |
| #define Mtyp_XML 6 |
| #define Mtyp_WRL 10 |
VRML1 10-19 tess-Formate.
| #define Mtyp_WRL2 110 |
VRML2.
| #define Mtyp_OBJ 11 |
| #define Mtyp_STL 12 |
| #define Mtyp_TESS 13 |
| #define Mtyp_BMP 20 |
20-29 PixelImages
| #define Mtyp_JPG 21 |
| #define MBTYP_EXTERN 0 |
| #define MBTYP_INTERN -1 |
| #define MBTYP_CATALOG -2 |
| #define TimeStamp float |
| #define OBJ_SIZ_MAX 160 |
160 = 5 * 32
max. obj-size (for get, copy ..)
| #define UT_BEZDEG_MAX 50 |
maximal degree of Bezier curve
| #define ATT_BIT_ABS 1 |
das Absolut-Bit; Achtung: 0=ON=absolut, 1=relativ.
| #define ATT_BIT_LIM 2 |
Limited; 0=On; 2=unbegrenzte Linie/Vollkreis.
| typedef double Mat_3x2[2][3] |
Typ_M3x2.
| typedef double Mat_3x3[3][3] |
Typ_M3x3.
| typedef double Mat_4x3[3][4] |
Typ_M4x3 size 96.
| typedef double Mat_4x4[4][4] |
Typ_M4x4.
| int MEM_swap__ | ( | void * | stru1, | |
| void * | stru2, | |||
| long | strSiz | |||
| ) |
MEM_swap__ 2 structs vertauschen MEM_swap__(&p1, &p2, sizeof(Point));
| int MEM_swap_short | ( | short * | i1, | |
| short * | i2 | |||
| ) |
| int MEM_swap_int | ( | int * | i1, | |
| int * | i2 | |||
| ) |
| int MEM_swap_2db | ( | double * | d1, | |
| double * | d2 | |||
| ) |
| int MEM_ins_rec | ( | void * | insPos, | |
| long | movSiz, | |||
| void * | insDat, | |||
| long | insSiz | |||
| ) |
MEM_ins_rec insert data into mem insDat data to insert insSiz size of insDat insPos where to insert movSiz how much bytes to move from insPos to insPos+insSiz
| int MEM_chg_rec | ( | void * | datStart, | |
| long * | datSiz, | |||
| void * | insDat, | |||
| long | insSiz, | |||
| void * | delPos, | |||
| long | delSiz | |||
| ) |
MEM_chg_rec change a record in mem (change line) Input: datStart Startposition des Datenblock datSiz Size Datenblock (zB ex strlen) insDat data to insert (len = insSiz) insSiz size of insDat delPos Position of old record (delete) and new record (insert) delSiz how much bytes to delete at Pos delPos Output: datSiz wird korrigiert strcpy(cbuf, "1234567890"); l1 = strlen(cbuf); MEM_chg_rec (cbuf, &l1, "AAA", 3, &cbuf[4], 1); // 5 -> AAA strcpy(cbuf, "1234567890"); l1 = strlen(cbuf); MEM_chg_rec (cbuf, &l1, "A", 1, &cbuf[4], 3); // 567 -> A see also MEM_chg_str
| int MEM_ins_nrec | ( | int * | recNr, | |
| void * | recTab, | |||
| int | ipos, | |||
| void * | insDat, | |||
| int | insRecNr, | |||
| int | sizRec | |||
| ) |
insert records into table.
insert data BEFORE Record with index ipos.
insert dataBlock insDat BEFORE dataRecord Nr ipos into Table recTab
recTab consists of *recNr records of size sizRec
Input/Output:
*recNr nr of records of table recTab;
after exit recNr += insRecNr
recTab table with *recNr records; each with a size of sizRec bytes.
after exit record nr ipos is the firsdt record of insDat ..
Input:
ipos index in recTab of the first inserted record of insDat
insDat data to insert; size = sizRec * insRecNr
insRecNr nr of records to insert
sizRec size of records (of recTab and insDat)
Example insert 1 point p31 into 3. position (index nr 2) of pTab:
MEM_ins_nrec (&recNr, pTab, 2, &p31, 1, sizeof(Point));
| int MEM_del_nrec | ( | int * | recNr, | |
| void * | recTab, | |||
| int | ipos, | |||
| int | delRecNr, | |||
| int | sizRec | |||
| ) |
delete <delRecNr> records from table.
first Record to delete has index ipos.
recTab consists of *recNr records of size sizRec
Input/Output:
*recNr nr of records of table recTab;
after exit recNr -= delRecNr
recTab table with *recNr records; each with a size of sizRec bytes.
Input:
ipos index in recTab of the first record to delete ..
delRecNr nr of records to delete
sizRec size of records of recTab
Example delete the 3. point (index nr 2) out of pTab:
MEM_del_nrec (&pNr, pTab, 2, 1, sizeof(Point));
| int MEM_del_IndRec | ( | int * | recNr, | |
| void * | recTab, | |||
| int | ipos | |||
| ) |
MEM_del_IndRec delete 1 integer in intArray recNr is decremented
| int MEM_del_DbRec | ( | int * | recNr, | |
| void * | recTab, | |||
| int | ipos | |||
| ) |
MEM_del_DbRec delete 1 double in double-Array recNr is decremented
| void MEM_del_pt | ( | int * | recNr, | |
| Point * | pa, | |||
| int | recInd | |||
| ) |
| void* MEM_ptr_mov | ( | void * | ptr, | |
| long | dist | |||
| ) |
| int UTP_comp_0 | ( | double | ) |
| int UTP_compdb0 | ( | double | , | |
| double | ||||
| ) |
UTP_compdb0 compare double mit 0.0 mit Tol. Retcode 0: db <> 0.0 (gr. oder kl. tol) 1: db = 0.0 (innerhalb tol)
| int UTP_comp2db | ( | double | , | |
| double | , | |||
| double | ||||
| ) |
| int UTP_comp2x2db | ( | double | d11, | |
| double | d12, | |||
| double | d21, | |||
| double | d22, | |||
| double | tol | |||
| ) |
UTP_comp2x2db compare 2 * 2 doubles (with tolerance) 2 * 2 Zahlen vergleichen; gleich=0; verkehrt=1; else=-1. RetCod: 0 d11 == d21; d12 == d22; beide Paare gleich. 1 d11 == d22; d12 == d21; beide Paare gleich, aber verkehrt. -1 d11 == d21; d21 != d22; -2 d11 == d22; d12 != d21 ACHTUNG: d12 == d22 wird nicht getestet ! -3 beide Paare ungleich.
| int UTP_db_ck_in2db | ( | double | v, | |
| double | v1, | |||
| double | v2 | |||
| ) |
| int UTP_db_ck_in2dbTol | ( | double | v, | |
| double | v1, | |||
| double | v2, | |||
| double | tol | |||
| ) |
| int UTP_db_cknear_2db | ( | double * | db, | |
| double * | d1, | |||
| double * | d2 | |||
| ) |
UTP_db_cknear_2db find nearest double out of 2 doubles RetCod 0 = db-d1 ist smaller than db-d2 RetCod 1 = db-d2 ist smaller than db-d1
| int UTP_db_cknear_ndb | ( | double | db1, | |
| int | dbNr, | |||
| double * | dbTab | |||
| ) |
UTP_db_cknear_ndb find nearest double out of dbTab
| double UTP_db_rnd1sig | ( | double | ) |
auf 1 sig. Stelle bringen:
(0.00579, 1) -> 0.006
(0.19500, 1) -> 0.2 (gerundet !!)
(1.00500, 1) -> 1.
(167.500, 1) -> 200.
| double UTP_db_rnd2sig | ( | double | ) |
auf 2 sig. Stellen runden
Geht nur mit pos. zahlen !!!!!
(0.00579, 1) -> 0.0058
(0.19500, 1) -> 0.19 (gerundet !!)
(1.00500, 1) -> 1.
(167.500, 1) -> 170.
| int UT1D_ndb_npt_bp | ( | double * | da, | |
| Point * | pa, | |||
| int | pNr, | |||
| int | bp | |||
| ) |
UT1D_ndb_npt_bp copy the backplane-part of a pointTable
| double UT_DEGREES | ( | double | ) |
| double UT_RADIANS | ( | double | ) |
UT2D_sidPerp_3pt check if p3 is in, before or behind perp-line tru p2 Ist p3 vor oder hinter der Linie, die durch p2 geht u.normal auf p1-p2 steht RC -1 p3 liegt vor Ebene p1-p2 (vis-a-vis) RC 0 p3 liegt genau in der Ebene RC 1 liegt hinter Ebene p1-p2 (in der Naehe von p2) p3 | x | . | . -1 0 +1 . | x--------------x p1 p2 see also UT3D_acos_2vc
| int UT2D_angr_set | ( | double * | angr | ) |
UT2D_angr_set change to val >= 0 <= RAD_360
| int UT2D_2angr_set | ( | double * | ang1, | |
| double * | ang2, | |||
| int | irot | |||
| ) |
UT2D_2angr_set change consecutive values from -RAD_360 to RAD_360 if irot == 1 (CCW) ang2 > ang1 if irot == -1 (CW) ang2 < ang1
| double UT2D_angr_2angr | ( | double | ang1, | |
| double | ang2, | |||
| int | irot | |||
| ) |
UT2D_angr_2angr angle between 2 angles (opening-angle) irot = 1 CCW irot = -1 CW
| int UT2D_ptNr_ci | ( | double | rdc, | |
| double | ao, | |||
| double | tol | |||
| ) |
Anzahl Ecken circ berechnen
| int UT2D_solvtriri_a | ( | double * | a, | |
| double | b, | |||
| double | c | |||
| ) |
UT2D_solvtriri_a right-angled tri: a from sides b and c C Der rechte Winkel liegt im Punkt C. / . \ / \ b a / \ A -------c-------- B c = hypotenuse a*a + b*b = c*c a = sqrt (c*c - b*b)
| int UT2D_solvtriri_ac | ( | double * | , | |
| double * | , | |||
| double | , | |||
| double | ||||
| ) |
UT2D_solvtriri_ac right-angled tri: q and hc from sides b and c. C Der rechte Winkel liegt im Punkt C. / | \ / | \ b hc a / | \ A -------c-------- B q p c = hypotenuse (baseline), b = side left, a = side right, hc is a normal to c. This normal parts c into q (lying under b) and p (lying under a). Returns: q - the length of b projected to c; hc - the length of the normal standing on c
| int UT2D_solvtri_abc | ( | double * | , | |
| double * | , | |||
| double | , | |||
| double | , | |||
| double | ||||
| ) |
UT2D_solvtri_abc scalene tri: q and hc from sides a, b and c. C Allgemeines Dreieck. Kein rechter Winkel. / | \ / | \ b hc a / | \ A -------c-------- B q p compute triangle. c is the baseline; b = side left, a = side right, (liegt gegenueber Punkt A !) hc is a normal to c. This normal parts c into q (lying under b) and p (lying under a). Input: the length of the sides a, b, c. Output: q - the length of b projected to c; (with direction - can be negativ !) hc - the length of the normal standing on c Retcodes: 0 - Ok. -1 - error; c = 0.; -2 - error; b > a + c; -3 - error; a > b + c;
check if 2 boxes overlap p1-p2 sind Box1, p3-p4 Box2. ACHTUNG: p1 muss links unter p2 liegen; p3 links unter p4. RC -1: NO, boxes do not overlap RC 1: yes boxes overlap.
check if Box2 is complete in Box1 p1-p2 sind Box1, p3-p4 Box2. ACHTUNG: p1 muss links unter p2 liegen; p3 links unter p4. RC -1: NO, boxes overlap RC 1: yes, Box2 is complete inside Box1
| double UT2D_angd_angr | ( | double | ) |
UT2D_angd_angr angle (degrees) = angle (radians)
| double UT2D_angd_invert | ( | double * | andi | ) |
UT2D_angd_invert ang(deg.) invert (change direction)
| double UT2D_angr_angd | ( | double | ) |
UT2D_angr_angd angle (radians) = angle (degrees)
| double UT2D_angr_triri_ab | ( | double | , | |
| double | ||||
| ) |
UT2D_angr_triri_ab right-angled tri: angle alfa from sides a and b. c = hypotenuse (baseline), b = side left, a = side right, the sides b - a include the right-angle. Returns the angle alfa (in rad; which is included by the sides b and c).
| double UT2D_angr_vc | ( | Vector2 * | ) |
UT2D_angr_vc angle (radians) = vector (0-360)
UT3D_angr_vc2pt angle between 2 points in plane (plane from pt-vc) get angle between lines pz-p1 and pz-p2, on a plane normal to vz. angle is CCW, 0 - PI*2 see also UT3D_angr_vcpl_z UT3D_angr_cipt UT3D_angr_ci UT3D_acos_2vc
UT3D_angr_vcpl_z compute angle of vec in Refsys (to X-axis) Compute the angle between vc1 and the X-vector of plane pl1 around the Z-axis of pl1. Input: pl1 Plane / Refsys vc1 Vector Output: angr angle in radians; min 0 max 2Pi (0-360 deg).
UT3D_angr_vcpl_tilt compute angle of vec in Refsys (to XY-plane) Compute the angle between vc1 and the XY-plane of plane pl1 around a vector normal to vc1 in the XY-plane of pl1 Input: pl1 Plane / Refsys vc1 Vector Output: angr angle in radians; min 0 max 2Pi (0-360 deg).
UT3D_angr_vc2vc compute angle of vec in Refsys (to X-axis) Compute the angle between vector vc1 in a refSys = plane from its X- and Y-vector around the Z-axis of this plane. vcx,vcy must be normalized ! the angle between vc1 - vcx is computed. Input: vcx, vcy defining the plane vc1 compute the angle between vcx-vc1 in the plane. Output: angr angle in radians; min 0 max 2Pi (0-360 deg). see also UT3D_angr_vcpl_z UT3D_angr_vc2pt
UT2D_angr_2vc angle (rad.) between 2 Vectors Die Vektoren muessen CCW liegen; vc1 entspricht der X-Achse; vc2 CCW davon.
UT3D_angr_4pt angle between 2 lines
UT2D_angr_ci openingAngle of circle (pa,pe,pc,rad/dreh) Der Winkel ist bei CW-Kreisen immer negativ (-360 - 0 - 360). Achtung: rad gibt auch die Drehrichtung ! CCW = rad > 0 ; CW = rad < 0 ;
UT3D_angr_cipt opening angle of point on Circ ACHTUNG: ES KANN KEIN VOLLKREIS ANALYSIERT WERDEN - ERGIBT Winkel 0 !! Oeffnungswinkel CCW von 0 bis 2 Pi; CW von 0 bis -2 Pi.
| double UT2D_angr_perpangr | ( | double * | ) |
UT2D_angr_perpangr angle + 90 degree (perp. to angle)
| double UT2D_len_vc | ( | Vector2 * | ) |
| double UT2D_lenq_vc | ( | Vector2 * | ) |
UT2D_lenB_2pt longest dx/dy-distance point-point (fast!)
UT2D_minLenB_4pt min lenght between 2 lines dp ist Streckensumme entlang der Hauptachsen - nicht genau Laenge ! rc = 1 p1e - p2a hat geringsten Abstand rc = 2 p1a - p2a hat geringsten Abstand rc = 3 p1e - p2e hat geringsten Abstand rc = 4 p1a - p2e hat geringsten Abstand dx,dy addieren; den geringsten Wert auswaehlen.
dp ist Streckensumme entlang der Hauptachsen - nicht genau Laenge !
rc = 1 p0 - p1 hat geringeren Abstand
rc = 2 p0 - p2 hat geringeren Abstand
dx,dy,dz addieren; den geringsten Wert auswaehlen.
dp ist Streckensumme entlang der Hauptachsen - nicht genau Laenge !
rc = 1 p1e - p2a hat geringsten Abstand
rc = 2 p1a - p2a hat geringsten Abstand
rc = 3 p1e - p2e hat geringsten Abstand
rc = 4 p1a - p2e hat geringsten Abstand
dx,dy,dz addieren; den geringsten Wert auswaehlen.
UT2D_len_ptln get (signed) minDist from pt to Line pa-pe
ck minimalAbst von pt auf Line pa,pe feststellen, ob der Normalpunkt auf oder ausserhalb Line ist (Normalpunkt = Projektion von pt auf Line pa-pe) Auf Line: den Abstand pt-NormalPt liefern (mit Vorzeichen) nicht auf Line: den Abstand zum naeheren Endpunkt liefern d1: Normalabstand od MindestAbstand dx: LaengsAbstand (der Abstand des NormalPunktes von pa) dy: der Normalabstand von pt zur Line pa-pe; Vorzeichen positiv: pt links von pa; negativ: rechts von pa. RetCod: -1 = vor pa; dy ist nicht gueltig ! 0 zwischen pa-pe; dx,dy sind gueltig 1 ausserhalb pe; dy ist nicht gueltig !
UT2D_slenq_ptptvc signed quadr.Distance pt-pt in Richtung vec pa - pb gives a line, pc is projected onto this line. c | | len | a--------+------b e see UT2D_sidPerp_3pt
UT2D_slen_nor3pt signed length of normal point - line gibt den Abstand den p2 auf die Linie p1 - p3 hat mit Vorzeichen. p2 | slen| | p1------+--------p3
UT2D_slen_nor2vc signed length of normal of 2 vectors gibt den Abstand den V2 auf V1 hat - mit Vorzeichen. x /| / | V2/ | / | / |slen / | .------+-------x V1
UT2D_slen_norvc2pt signed length of normal vector - vector For true length v1 must be normalized ! see UT2D_acos_2vc . p2 . X . . . . v2 . sk = Normalabst von vec p1-p2 auf vec p1-v1 . . . . . . X-----------------.------- p1 v1
UT2D_len_ptlnX Laengsabst.(m.Vorz.) eines Punktes auf Linie (pl-vl) Achtung: liefert den Abstand von pl nach pt ! (den X-Wert der Normalen von pt auf pl/vl). Vorzeichen: wenn pl in 0,0 und vl als 1,0 angenommen wird, entspricht der Abstand dem X-Wert; Vorzeichen also Positiv bei pt= rechts von pl-vl.
UT2D_len_ptlnY Normalabst.(m.Vorz.) eines Punktes von Linie (pl-vl) vl muss nicht normalisiert sein. Vorzeichen: wenn pl in 0,0 und vl als 1,0 angenommen wird, entspricht der Abstand dem Y-Wert; Vorzeichen also Positiv bei pt= oberhalb von pl-vl.
UT2D_2len_ptvc dx,dy = dist pt - pb along / normal to vector vc Input: pb,vc - define the axissystem (origin and x-axis) pt - point in this axissystem Output: dx - gives the distance along vc from pb to pt (can be negativ !) dy - gives the distance normal to vc from pb to pt (can be negativ !)
| int UT2D_irot_r | ( | double | r | ) |
UT3D_cklr_2vc check vc for left (CCW, above) or right (CW, below) Vektoren muessen nicht normiert sein ! RC -1 v2 is CW from v1 (neg. angle) RC 0 v1-v2 are parallel RC 1 v2 is CCW from v1 (pos. angle) see also UT2D_sidPerp_2vc
UT2D_sidPerp_2vc check vecs for inFront, perp.(normal), or behind Ist v2 vor oder hinter einem Normalvektor auf v1 durch den Startpunkt von v1. sind Vektoren eher parallel oder anpiparallel .. Vektoren muessen nicht normiert sein ! RC -1 vecs point into opposit direction (angle > 90 deg.) RC 0 vecs are perpendicular (angle = 90 deg) RC 1 vecs point into same direction (angle < 90 deg) see also UT2D_sid_2vc UT3D_acos_2vc
UT2D_sid_3pt compare if pt is on, above or below line (p1-p2) 0 pt is on vector vl 1 pt is above vector vl (left side) -1 pt is below vector vl (right side)
UT2D_sid_ptvc compare if pt is on, above or below line (pl+vl) was UT2D_dir_ptvc X pt 1 pl ----------X---vl-----------> X pt -1 retcode: 0 pt is on vector vl 1 pt is above vector vl (left side) -1 pt is below vector vl (right side)
UT2D_sidPerp_ptvc compare if pt is right/on/left of a normal to pl+vc pt | pt -1 | 1 | |--------->vl ----------X---------------- pl | retcode: 0 pt is on a normal to line pl-vl 1 pt is before pl (to the right side of a normal to line pl-vl) -1 pt is behind pl (to the left side of a normal to line pl-vl)
UT3D_sid_2vc check vc's for perp, same or opposit direction test if vectors are parallel or anpiparallel or normal .. RC -1 vc's point into opposit direction RC 0 vc's are perpendicular RC 1 vc's point into same direction see also UT3D_acos_2vc
UT3D_sid_3pt check if pt is in, before or behind perpendic.Plane Ist p3 vor oder hinter der Ebene, die durch p1 geht u.normal auf p1-p2 steht RC -1 p3 liegt vor Ebene p1-p2 (vis-a-vis) RC 0 p3 liegt genau in der Ebene RC 1 liegt hinter Ebene p1-p2 (in der Naehe von p2) see also UT3D_acos_2vc
UT3D_sid_ptpl compare if pt is in, above or below plane retcode: 0 pt is in plane pl 1 pt is above plane pl (same side as the z-vector) -1 pt is below plane pl
UT3D_sid_ptptvc compare if pt is in, above or below plane Plane is defind by origin pto and z-vector vz retcode: 0 pt is in plane pl 1 pt is above plane pl (same side as the z-vector) -1 pt is below plane pl
get parameter (0-1) of point px along line p1-p2
see also UTP_param_p0p1px
UT2D_ar_3pt get (signed) area of triangle see also UT2D_srar_inpt3 UFA_ar_fac
UT2D_comp4pt compare 4 2D-points Ob 2 der 4 Punkte zusammenpassen (zum Test ob 2 Lines einen gemeinsamen Punkt haben). Retcode 0 = Abstand aller Punkte > tol 1 = Abstand (p1e - p2a) < tol 2 = Abstand (p1a - p2a) < tol (Obj 1 verkehrt) 3 = Abstand (p1e - p2e) < tol (Obj 2 verkehrt) 4 = Abstand (p1a - p2e) < tol (Obj 1 und 2 verkehrt)
test ob die Linien p1-p2 und p3-p4 sich schneiden/beruehren/parallel sind
rc=-1: kein Schnittpunkt
rc=0: die Linien beruehren sich
rc=1: die Linien sind (teilweise) parallel
rc=2: die Linien schneiden sich
see UT2D_pt_int2vc2pt
UT2D_pt_ck_inLine check 2D-point on line segment Check if a 3. 2D-point lies inside the line segment defined by two 2D-points. It is assumed that the 2D-point is ON the line defined by the two 2D-points. IN: Point2 p1 ... 2D-point 1 defining the line segment Point2 p2 ... 2D-point 2 defining the line segment Point2 p3 ... 2D-point to check double tol ... tolerance for 2D-point to ly inside line segment (>0) OUT: Returncodes: 0 = the 2D-point lies outside the segment 1 = the 2D-point lies inside the segment
| int UT2D_pt_ck_linear | ( | int | np, | |
| Point2 * | ptab, | |||
| double | tol | |||
| ) |
UT2D_pt_ck_linear check straight position of 2D-points Check if the position of 2D-points is straight. IN: int np ... number of 2D-points Point2 *ptab ... 2D-points double tol ... tolerance for straightness (>0) OUT: Returncodes: 0 = position of points is not straight 1 = position of points is straight
UT2D_pt_ck_inBox check if point p is inside box p1-p2 RC = 0: YES, p is inside box p1 / p2 RC = 1: NO, p is outside box p1 / p2
UT2D_pt_ck_inBoxTol check if point p is inside box p1-p2 RC = 0: YES, p is inside box p1 / p2 RC = 1: NO, p is outside box p1 / p2
UT2D_pt_ck_inAc check if pt is in Arc(Segment) Vektor Cen-Pt muss Arc schneiden; else not in Arc. Es wird der Radius nicht kontrolliert; auch nicht die gegenUeberseite. RetCod: 0 = yes, pt is in Arcsegment; -1,-2,1,2 = no.
UT2D_pt_ck_inCv3 check if point is inside polygon geschlossene Kontur erforderlich; pTab[pNr-1] muss gleich wie pTab[0] sein irc 1 Punkt liegt innerhalb der Kontur irc 0 Punkt liegt auf der Kontur irc -1 Punkt liegt ausserhalb der Kontur Schnittpunkte aller Kantenlinien mit Horzontale Linie durch ptx rechts von ptx zaehlen; ungerade == innen.
UT2D_pt_cknear_npt return index of nearest Point from n points use: pt1 = ptTab[UT2D_ipt_cknear_npt (&ptStart, ptTab, ptNr)];
| void UT2D_pt_2db | ( | Point2 * | , | |
| double | , | |||
| double | ||||
| ) |
UT2D_pt_tra2ptlen transl. point p1 into dir p1 -> p2 dist. lenv
UT2D_pt_traPtPtPar transl. pt with parameter along p1-p2 see UT3D_pt_evpar2pt UT3D_vc_multvc UT2D_pt_traptvc
UT2D_pt_tra3ptlen transl. point p1 into dir p2 -> p3 dist. lenv
UT2D_pt_tra2pt2len transl. point into dir p1 -> p2 dist. dx and normal dy
UT2D_pt_tra2pt3len move p1; Baseline p1-p2; Dir dx/dy; length lenv.
UT2D_pt_traptvclen move pi along vc length lenv
UT2D_pt_traptangrlen move point; direction from angle, distance=lenv
UT2D_pt_tranor2ptlen transl. point normal to p1 - p2 dist. lenv Center is p1; p1-p2 gives the baseline
UT2D_pt_tranorptvclen transl. point normal to vec dist. lenv Center is p1; p1-v1 gives the baseline
UT2D_pt_traptvc2len transl. point into dir vc; dist. dx and normal dy Move point into direction vc with distance dx and normal to vc - with distance dy.
UT2D_pt_tracirlen transl. point circular length rad = Radius; Pos.Val = CCW; neg.Val =CW. clen = arcLenght
UT2D_pt_rotptangr rotate a point around centerpoint p2 darf ident mit p1 sein.
UT2D_pt_projptptvc point = project point to line (pt+vc) Project a point onto a line given by point and vector. pl - vl gives a line, pt is projected onto this line. IN: Point2 *pt ... point to project on line pl-vl Point2 *pl ... point on line Vector2 *vl ... vector of line OUT: Point2 *pp ... normal projection of pt onto line Returncodes: 0 = OK 1 = point is on line
UT2D_pt_projpt2pt pp = project point pt to lineSegment p1-p2 p1-p2 is a line, pt is projected onto this line. len ist the len pt-pp (if not NULL) -1 1 0 2 -2 retcod | pt | | len| | p1------+--------p2 pp Input: len NULL or address Output: pp pr projected to p1-p2 len distance pt-pp if not NULL on input retcod 0=OK, pp is on line, between p1-p2 1 OK; pp = p1 2 OK; pp = p2 -1 outside; pt is before line -2 outside; pt if after line -3 Input-Error; p1==p2 see also UT3D_pt_ck_ptvc UT3D_pt_ck_onLine UT3D_nlen_2ptvc UT3D_pt_projptptvc UT3D_pt_projptln
UT2D_pt_projptln point = project point to line
UT2D_2pt_projptci project point to circle ip1 ist the nearer solution, ip2 is farer away from cen
UT2D_pt_projptci project point to Arc (segment of circle) 2 solutions: der nearest point is selected. RetCod: 0 = yes, pp is in Arcsegment; -1 = no; none of the 2 projectionpoints is on the ArcSegment.
| int UT3D_ptDi_intptvcptvc | ( | Point * | ip, | |
| double * | dist, | |||
| Point * | ptl, | |||
| Vector * | vcl, | |||
| Point * | ptp, | |||
| Vector * | vcp | |||
| ) |
intersect line-plane (pt-vc pt-vc)
ip = project pt1 along vcl onto plane ptp-vcp
Output:
dist = der Faktor fuer den Abstand vom pt zum ip in Richtung vln.
vln * dist ab pt ergibt ip.
Returncodes:
0 = vc parallel to plane
1 = OK;
UT3D_ptDi_intptvcpln intersect line-plane (pt-vc pt-vc) provide also parameter of intersection-point on line. Von pl wird nur p und vz benutzt. Output: dist = der Faktor fuer den Abstand vom pt zum ip in Richtung vln. vln * dist ab pt ergibt ip. Returncodes: 0 = vc parallel to plane 1 = OK; see also UT3D_pt_intplnln UT3D_pt_intlnpl1 UT3D_pt_intptvcpln see also UPRJ_app_pt UT3D_pt_intptvcplx/y/z
intersection of 2 limited lines
Info, ob Schnittpunkt ident mit p1 oder p2 (p3,p4 werden nicht getestet)
Info, ob p1-p2 und p3-p4 uebereinanderliegen (ueberlappen)
RC = -1 NO; Point outside Line p1-p2
RC = 0 Yes; intersect; ps=p1; dp1=0;
RC = 1 Yes; intersect; ps between p1-p2;
dp1 ist der Abstandswert (0-1) des Schnittpunktes entlang p1-p2
RC = 2 Yes; intersect; ps=p2; dp1=1;
RC = 3 Lines parallel - Endpoints touch (not overlap). ps, dp1 unused.
RC = 4 Lines parallel and overlap; ps, dp1 unused.
UT2D_pt_int2ln point = intersection of 2 lines Returncodes: 0 = Lines parallel or zero-length 1 = OK.
UT2D_pt_intptvcy intersection line (pt-vc) - horizontal line Schnittpunkt eines Linesegmentes ln1 mit einer unendlich langen, horiz. Geraden mit Y=yVal errechnen. Retcod= 0: Schnittpunkt in pto Retcod= 1: Linie vertical; beliebig viele Schnittpunkte
UT2D_pt_intlny intersection linesegment - horizontal line Schnittpunkt eines Linesegmentes ln1 mit einer unendlich langen, horizontalen Geraden mit Y=yVal errechnen. Retcod= 0: Schnittpunkt in pto Retcod=-1: kein Schnittpunkt Retcod= 1: Linie horizontal; beliebig viele Schnittpunkte
UT2D_pt_int2pt2vc point = intersection of 2 vectors + 2 Points intersection of 2 unlimited lines Returncodes: 0 = Lines parallel or zero-length 1 = OK; ip = intersectionPoint; see also UT2D_pt_int2vc2pt
UT2D_pt_int2vc2pt point = intersection of 2 vectors + 2 Points Es wird auch getestet, ob der Schnittpunkt ip sich auf oder ausserhalb des vc1 / vc2 befindet. Returncodes: 0 = Lines parallel or zero-length 1 = OK; Schnittpunkt befindet sich auf vc1 und auf vc2. 2 = OK; Schnittpunkt befindet sich nicht auf vc1 (vc2 wird nicht getestet) 3 = OK; Schnittpunkt befindet sich auf vc1, nicht auf vc2.
UT2D_2pt_intciptvc intersect Circle - Line (pt+vc) ip1 immer jener Punkt, Return code: 0 ... normal intersection (2 Ergebnispunkte) 1 ... circle touches line -1 .. no intersection
UT2D_2pt_intlnci intersect Line x Circ; both limited or unlimited lnMode 0=limited Line, 1=unlimited Line. ciMode 0=limited Circ, 1=unlimited Circ. Retcod 1/2 number of intersectionpoints -1 no intersectionpoint
UT2D_2pt_intcici intersect 2 Circles Return code: 0 ... normal intersection 1 ... circles touch each other -1 .. circles do not intersect
| int UT2D_2pt_int2ci | ( | Point2 * | ip1, | |
| Point2 * | ip2, | |||
| Circ2 * | ci1, | |||
| int | ci1Mode, | |||
| Circ2 * | ci2, | |||
| int | ci2Mode | |||
| ) |
UT2D_2pt_int2ci intersect Circ x Circ; both limited or unlimited ciXMode 0=limited Circ, 1=unlimited Circ. Retcod 1/2 number of intersectionpoints -1 no intersectionpoint
UT2D_pt_traptm2 einen 2D-Punkt mit 3x2-Matrix transformieren. - transform point von Refsys ma nach absolut (mit normaler Matrix) - transform point von absolut Refsys ima (mit inverser Matrix) Ausgabe: ein Punkt im 2D-System mata, gedreht um Center/Vektor in mata.
UT2D_pt_obj2 2D-Obj > 2D-Point DO NOT USE
| void UT2D_ln_inv | ( | Line2 * | ln1 | ) |
| void UT2D_ln_4db | ( | Line2 * | ln2, | |
| double | xs, | |||
| double | ys, | |||
| double | xe, | |||
| double | ye | |||
| ) |
UT2D_ln_4db 2D-Line from 4 doubles
UT2D_ln_obj2 2D-Obj > 2D-Line DO NOT USE
| int UT2D_lncoe_ln | ( | double * | k, | |
| double * | d, | |||
| Line2 * | ln | |||
| ) |
UT2D_lncoe_ln coefficients of 2D Line Coefficients of 2D-Line equation y = k*x + d, if the line is NOT parallel to the y-axis. IN: Line2 *ln ... 2D-line OUT: double *k ... coefficient k double *d ... coefficient d Returncodes: 0 = OK 1 = line parallel y-axis
UT2D_ln_pts_dmax line <-- points with max. distance of pointTab. Computation of a 2D-line from a set of 2D-points. The line points will be such that their distance is maximal! Die am weitesten auseinanderliegenden Punkte suchen, Linie davon machen. IN: int np ... number of 2D-points Point2 *ptab ... 2D-points double tol ... tolerance: minimal desired distance between 2D-line points OUT: Line2 *ln ... 2D-line with maximal point distance Returncodes: 1: line exists 0: no line exists
UT2D_comp2vc compare 2 vectors for parallel and antiparallel Vectors must not be normalized. tol applies to length 1 Returns 1 if parallel=yes, else 0. if(UT2D_comp2vc(&vc1, &vc2, UT_TOL_pt)) printf(" parallel=yes");
UT2D_comp2vc_p compare 2 vectors for parallel Compare directions; lenght is normalized (tol applies to length 1) Returns 1 wenn parallel, else 0.
UT2D_ckvc_in2vc check if v2 is between v1 and v3 the opening-angle of v1-v3 is less than 180 deg. RetCod: 0 = no; v2 is NOT between v1 and v3 1 = yes; v2 = between v1 and v3
UT2D_2parvc_3vc project end of vec1 along vec2 on vec3 Zu gegebenen Vektoren v1, v2, v3 finden wir Zahlen x und y so, dass x * v1 + y * v3 = v2. dx/dy sind zwischen 0 bis 1; wenn dx=0.5 liegt der Endpunkt von V2 genau in der Mitte des Parallelogramss V1-V3. y \ \ V1,V2,V3 have same startpoint s. dy \-----------x \ / \ \ / \ V3 \ V2 \ \ / \ \ / \ s----------------------------x dx V1
| void UT2D_vc_2db | ( | Vector2 * | , | |
| double | , | |||
| double | ||||
| ) |
| void UT2D_vc_angr | ( | Vector2 * | , | |
| double | ||||
| ) |
| void UT2D_vc_angrlen | ( | Vector2 * | , | |
| double | , | |||
| double | ||||
| ) |
UT2D_vc_angrlen 2DVector = angle (radians) + Length
UT2D_vc_2pt3 2D-Vector = 3D-Point -> 3D-Point
2D-Vector = (3D-Point -> 3D-Point) on Backplane
UT2D_vc_2ptlen 2D-Vector = 2D-Point -> 2D-Point, set Length
UT2D_vc_setLength change 2D-Vectorlength vco and vci may be the same address if length of vci is known: UT2D_vc_multvc (&vco, &vci, newLengthOfVco / actLengthOfVci);
UT2D_vc_mid2vc vector = midVector between 2 vectors
UT2D_vc_merge2vc merge 2 vectors vNew = (v1 + v2) / 2
UT2D_vc_rotangr rotate a 2D_vector (vco and vci can be the same adress)
UT2D_vc_travcm2 2D-vector transformation (3x2-matrix) UT2D_vc_travcm2 Author: Thomas Backmeister 9.4.2003 Transformation of a 2D-vector with a 3x2-matrix. IN: Mat_3x2 mata ... transformation matrix Vector2 *vi ... 2D-vector OUT: Vector2 *vo ... transformed 2D-vector
| double UT2D_angr_ciSec | ( | double | hc, | |
| double | radc | |||
| ) |
UT2D_angr_ciSec opening angle of Secant of Circ for length of secant see UT2D_len_ciSec
| double UT2D_len_ciSec | ( | double | hSec, | |
| double | rCi | |||
| ) |
UT2D_len_ciSec cmp length of secant from radius + height of secant. Gegeben: _ - + - _ x = hSec = Hoehe der sekante ^ |x ^ c = rCi = radius Kreis / | \ +---a-----+---a-----+ Gesucht: | / a = lSec = halbe Laenge der Sekante b| / | /c b = c - x | / a*a + b*b = c*c + a = sqrt (c*c - b*b) CirCen
| double UT2D_len_cia | ( | double | rad, | |
| double | ango | |||
| ) |
UT2D_len_cir length circular arc (pa,pe,pc,rad/dreh) Laenge immer positiv (angOpe nicht !) Liefert auch den Oeffnungswinkel angOpe. Achtung: rad gibt auch die Drehrichtung ! CCW = rad > 0 ; CW = rad < 0 ;
| int UT2D_compPtOnAc | ( | double | , | |
| double | , | |||
| double | , | |||
| int | ||||
| ) |
Testen, ob sich ein Punkt auf einem Arc befindet. Die Winkel
sind Input (ev. aus UT2D_angr_ptpt).
Out als RetCod: YES oder NO.
UT2D_ci_ptrd 360-deg 2D-Circ from center, radius
circ from point and point+tangentVector
Input:
ps = Startpunkt des Cir,
vcs = Startvektor
pe = ein Punkt am Kreis
Output:
pc = Mittelpunkt
radc = Radius; ACHTUNG: negativ bei CW
UT2D_obj_obj3 change 3D-Obj > 2D-Obj (remove Z-val) 3D-Objekt in 2D-Objekte umwandeln (remove Z-Wert)
UT2D_obj_ln3 change 3D-Line > 2D-Obj DO NOT USE
UT2D_obj_ci2 change 2D-Circ > 2D-Obj DO NOT USE
UT2D_obj_ci3 change 3D-Kreis > 2D-Obj DO NOT USE
UT2D_obj_cv3 change 3D-Curve > 2D-Obj Die Indices (der Punktekette) sind in pc.x/pc.y. DO NOT USE
| int UT2D_void_obj2 | ( | void * | memObj, | |
| unsigned long * | oSiz, | |||
| ObjG2 * | og2 | |||
| ) |
change ObjG2-Objekt -> data-Obj DO NOT USE
Vollkreis --> Polygon.
insgesamt ptNr Punkt; erster und letzter sind gleich.
UT2D_cv_ln Linearstueck -> Polygon.
UT2D_npt_ci circular polygon see also UT2D_cv_cin UT2D_pt_rotptangr
UT2D_cv_ci change circle > polygon nur CCW. Max 64 Segments. Sehr schnell. Erstes und letztes Segment haben unterschiedliche Groesse. the circle is divided into 64/idiv segments.
| int UT2D_cv3_linear | ( | int * | pNr, | |
| Point * | pTab, | |||
| double | tol | |||
| ) |
UT2D_cv3_linear delete unnecesary straight points alle Punkte die innerhalb tol liegen aus pTab entfernen. ACHTUNG: pTab sind 3D-Punkte; Z ignorieren !
| int UT2D_srar_polc | ( | double * | aro, | |
| int | ptNr, | |||
| Point2 * | pa | |||
| ) |
UT2D_srar_polc nach Karl Sauer 2004-04-07 Umlaufsinn (sr=sense of rotation) und Flaeche (ar=area) eines geschlossenen 2D-Polygons (polc) berechnen. ptNr = Anzahl Punkte ohne den letzten == ersten Punkt ! pa = PunkteTabelle ohne den letzten == ersten Punkt ! RetCod = 1 = CCW -1 = CW
UT2D_m2_load 2D-Refsys from baseDirection, basePoint.
UT2D_m2_loadtravcm2 load 2D-vector trafo (3x2 matrix) Load a 2D-vector transformation with 3x2-matrix. IN: Vector2 *vx ... vector 1 Vector2 *vy ... vector 2 Vector2 *vt ... translation vector OUT: Mat_3x2 ma ... transformation matrix
UT2D_m2_invtravcm2 invert 2D-vector transformation Inversion of a 2D-vector transformation. IN: Mat_3x2 m1 ... transformation matrix OUT: Mat_3x2 im1 ... inverse transformation matrix Returncodes: 0 = OK 1 = no inverse trafo
UT2D_m3_init_rot Initialize a 3x2 - matrix with rotation
| int UT3D_stru_dump | ( | int | typ, | |
| void * | data, | |||
| char * | txt, | |||
| ... | ||||
| ) |
UT3D_stru_dump Testausgabe Geom.Element. typ = TYP_FuncInit: ab nun Ausgabe -> Datei "txt" (Open File) typ = TYP_FuncEnd: ab nun wiederAusgabe -> term. (Close File) typ = TYP_FuncInit1: ab nun Ausgabe -> FILE "txt" (File must be open) typ = TYP_FuncExit: ab nun wiederAusgabe -> term. (does not close File)
| double UT3D_len_vc | ( | Vector * | ) |
| double UT3D_lenq_vc | ( | Vector * | ) |
| int UT3D_bplen_vc | ( | double * | lnv, | |
| Vector * | vc1 | |||
| ) |
UT3D_lenB_2pt longest dx/dy/dz-distance point-point (fast!)
UT3D_lenq_PtPt square-distance point - point alias UT3D_lenq_2pt nur Abstand ohne sqrt ausrechen (nur f Vergleichswert)
UT3D_lenq_PtLn minimum (quadr) distance Point-Segment give min. distance from Point p to Line p1-p2 see also UT3D_nlenq_3pt
| double UT3D_len_ln | ( | Line * | ) |
UT3D_len_ln length of line
| double UT3D_len_ci | ( | Circ * | ci1 | ) |
UT3D_len_ci length of circ immer pos.
UT3D_slen_3pt signed distance point - point p1-p2 gives the direction, OUT: signed distance p1-p3 ........ p3 . . . . . . . . p1--------+------>p2 <---rc--->
UT3D_slen_projvcvc signed length of vector projected on vector length of vc1 does not influence result. 3D-Projektionslaenge eines Vektors auf einen anderen Vektor: vc2 wird auf vc1 projiziert. negativ if Oeffnungswinkel > 90 Grad if (length of vc1 = 1): use UT3D_skp_2vc /| V2/ | / | / | x--------+------> V1 <---rc--->
Quadr.3D-Projektionslaenge eines Vektors auf einen anderen Vektor:
vc2 wird auf vc1 projiziert.
negativ if Oeffnungswinkel > 90 Grad !
ACHTUNG: sqrt von einem negativen Wert geht ned !!!!
see also UT3D_ptDi_intptvcpln
/|
V2/ |
/ |
/ |
x--------+------> V1
<---rc--->
UT3D_slenq_2ptvc Quadr. Laenge pt-pt in Richtung vec (m. Vorzeichen !) die wahre Laenge ist sqrt(fabs(lq))*DSIGN(lq) see also UT3D_slenq_projvcvc p2 /| / | / | / | p1--------+------> VC <---rc--->
3D-Normalabstand eines Vektors auf einen anderen Vektor:
vc2 wird auf vc1 projiziert.
_
/| |
V2/ | |
/ vc3 l3=rc
/ | |
/ | |
x--------+------------> V1
|---v1x--|
UT3D_slen_2ptvc signed length of (p1-(p2 projected on (p1-vc)) Laenge pt-pt in Richtung vec (m. Vorzeichen !) Wenn vc normiert ist (Laenge 1) dann genuegt Skalarprodunkt (UT3D_acos_2vc) p1-vc definieren eine Plane; p1=Origin, vc=Normalvektor. p2 auf die Plane p1-vc projizieren (ergibt ps); die Laenge p2-ps liefern. ........ p2 . . . . . . . . p1--------+------> vc <---rc--->
UT3D_slen_ptpl signed distance point - plane Value is positive point ON same side as plane normal vector Value is negativ point on OPPOSITE side of plane normal vector
UT3D_nlen_2ptvc Laenge der Normalen auf Vektor 2003-11-07: p1-p2 vertauscht! RF. p1 auf pv-vc projizieren (ergibt ps); die Laenge p1-ps liefern. (p1 -ps ist normal auf vc) X p1 | rc | | pv------+--------> vc see also UT3D_pt_ck_ptvc UT3D_pt_ck_onLine UT3D_nlen_2ptvc UT3D_pt_projptptvc
UT3D_nlen_3pt Laenge der Normalen von p2 auf Line p1-p3 p2 liegt in der Mitte; p1-p3 ist die Linie. p2 wird auf die Linie projiziert; der Abstand ist der Rueckgabewert. X p2 | rc | | p1------+--------p3
| int UT3D_parpt_objpt | ( | double * | po, | |
| Point * | pti, | |||
| int | oTyp, | |||
| void * | oDat | |||
| ) |
UT3D_parpt_objpt give parameter of point on curve ACHTUNG: liefert (auch fuer B-Splines) immer Werte zwischen 0-1 !
UT3D_parpt_3pt parameter of distance of point ptx on line pl1-pl2 pl ist zwischen 0 bis 1; wenn pl=0.5 liegt ptx genau in der Mitte von pl1-pl2 ptx X /| / | / | / | / .| X-----|------------X pl1 pl=0.4 pl2 RetCodes: 0 OK -1 v1-v2 aufeinander Normal; pl = 0.
UT3D_parpt_ptvc parameter of distance of point ptx on line pt1-vc1 pl ist zwischen 0 bis 1; wenn pl=0.5 liegt ptx genau in der Mitte von pl1-pl2 ptx X /| / | / | / | / .| X-----|------------>X pt1 pl=0.4 vc1 RetCodes: 0 OK -1 v1-v2 aufeinander Normal; pl = 0.
UT3D_parpt_lnbp parameter of point on line (via 2D,BackPlane) bp = Berechnungsebene BackPlane ex UT3D_bp_vcz
UT3D_parpt_ci parameter of point on circ
par = gesamtlaenge_circ / laenge_von_p1_bis_pti
laenge_circ = radius * Angle
UT3D_pt_ck_npt compare point / points check if p0 ist identical with one of the points of pTab Retcode: irc = -1 all points have a distance > tol irc >= 0 index of (first) identical point;
UT3D_ipt_cknear_npt return index of nearest Point from n points
UT3D_ipt_ckfar_npt return index of farest Point from n points
UT3D_ipt_cknearn_npt return index of n-nearest Point from n points distNr=0: return index of nearest point; distNr=1: return index of 2.nearest point ...
ind. of outermost points in direction vc of n pt's mode 0 = start, >0 = resume see UT3D_slen_2ptvc UT3D_slen_ptpl
UT3D_pt_ck_onel check if point lies on an (full) ellipse Check if a point lies on an (full) ellipse. It is assumed that the point lies in the plane of the ellipse. IN: Point *pt ... 3D-point CurvElli *el ... 3D-ellipse OUT: Returncodes: 0 = point is not on the ellipse 1 = point is on the ellipse -1 = internal error
UT3D_pt_ck_ptvc check if point is on unlimited line (point-vector) RC = -1 NO; Point pt is outside Line pl1-pl2 RC = 0 Yes; pt is nearer than tol to line pl1-pl2 see also UT3D_pt_ck_ptvc UT3D_pt_ck_onLine UT3D_nlen_2ptvc UT3D_pt_projptptvc UT3D_pt_projptln
UT3D_pt_ck_2pt check if point is on unlimited line (2 points) RC = -1 NO; Point pt is outside Line pl1-pl2 RC = 0 Yes; pt is nearer than tol to line pl1-pl2 see UT3D_pt_projptptvc UT3D_pt_projptln UT3D_pt_ck_onLine
liegt p3 auf der Linie p1-p2 ? (Tests mit UT_TOL_pt) RC = -1 NO; Point outside Line p1-p2 RC = 0 Yes; p3=p1; po=p1. RC = 1 Yes; po between p1-p2 RC = 2 Yes; p3=p2; po=p2. see also UT3D_pt_ck_ptvc UT3D_pt_ck_onLine UT3D_nlen_2ptvc UT3D_pt_projptptvc UT3D_pt_projptln
UT3D_pt_ck_inLine check point on line segment Check if a 3. point lies inside the line segment defined by two points. It is assumed that the point is ON the line defined by the two points. IN: Point p1 ... point 1 defining the line segment Point p2 ... point 2 defining the line segment Point p3 ... point to check double tol ... tolerance for point to ly inside line segment (>0) OUT: Returncodes: 0 = the point lies outside the segment 1 = the point lies inside the segment
check if point is on perp.plane between 2 points
x p3
|
p1 x-------|--------x p2
RetCod
0 not OK; p3 has different distances from p1 and p2
1 OK; p3 has the same distance from p1 and p2
testen, ob pt1 AUF Polygon liegt
RetCod 0 pt1 is on polygon ptab
RetCod -1 pt1 is not on polygon ptab
check if point p3 is inside box of points p1-p2
Returncodes:
-1 = the point lies outside the box
0 = the point lies inside the segment
UT3D_pt_ck_inSph check if point is inside sphere irc: 1 = YES point lies inside 0 = --- point touches -1 = NO point lies outside
UT3D_comp4pt compare 4 points Ob 2 der 4 Punkte zusammenpassen (ob 2 Lines einen gemeinsamen Punkt haben). Es wird nur der Abstand entlang der Hauptachsen getestet ! rc=0: keine Verbindung rc=1: bei El. liegen richtig. rc=2: Obj 1 verkehrt rc=3: Obj 2 verkehrt rc=4: Obj 1 und Obj 2 verkehrt Retcode 0 = Abstand aller Punkte > tol 1 = Abstand (p1e - p2a) < tol (beide Obj. liegen korrekt) 2 = Abstand (p1a - p2a) < tol (Obj 1 verkehrt) 3 = Abstand (p1e - p2e) < tol (Obj 2 verkehrt) 4 = Abstand (p1a - p2e) < tol (Obj 1 und 2 verkehrt)
| void UT3D_pt_txt | ( | Point * | , | |
| char * | ||||
| ) |
UT3D_pt_txt Point from text delimiters: blank, comma, comma and blank .. eg: "100 23 45"
UT3D_pt_mid2pt midpoint between 2 points po may be p1
arithm. Mittelwert der Punktetabelle pTab (alle Punktcoord addieren dann durch PunkteAnzahl divid.)
UT3D_pt_opp2pt opposite point (p1 = center) p1 und po duerfen ident sein.
UT3D_pt_oppptptvc point opposite line (= 180 deg rot.)
UT3D_2pt_oppptvclen 2 opposite points (center, vector, dist) pc is center, p1 is direction vc1 from pc, p2 in reverse direction.
UT3D_pt_ptvclen transl. point into dir vc dist. lenv
Move point into direction vc with distance dx.
po and pi may be identical.
====.==================================================================
UT3D_pt_traptvc1len transl. point into dir vc dist.lenv (vcLen=1) Vector has Length 1.; Point = basePoint + (vec * len)
UT3D_pt_trapt2vc transl. point into 2 directions po kann mit pi ident sein.
UT3D_pt_trapt2vc2len transl. point into 2 directions (2 len's) Move point into direction vc with distance dx. po kann mit pi ident sein.
| void UT3D_pt_trapt3vc3len | ( | Point * | po, | |
| Point * | pi, | |||
| Vector * | vx, | |||
| double | dx, | |||
| Vector * | vy, | |||
| double | dy, | |||
| Vector * | vz, | |||
| double | dz | |||
| ) |
UT3D_pt_trapt3vc3len transl. point into 3 directions (3 len's) Move point into direction vx,vy,vz with distance dx, dy dz. po kann mit pi ident sein.
UT3D_pt_traptptlen transl. point into dir pDir dist. lenv Move point into direction pi->pDir with distance lenv. po kann mit pi ident sein.
UT3D_pt_trapt2pt transl. point distance p1 -> p2
UT3D_pt_tracirlen transl. point circular length CCW = rad > 0 ; CW = rad < 0 ;
UT3D_pt_rotptptangr rotate pti around ptc/Z-Axis
Punkt pti um die Achse pta/vca um angr weiterdrehen
angr = -2Pi bis +2Pi.
ACHTUNG: vca muss normiert sein !!
Rotate Point (prepare with UT3D_m3_inirot)
Kreisstartpunkt p1 um die Achse vz um angr weiterdrehen
pc und p1 muesssen am gleichen Kreis liegen (sonst ev 2 x UT3D_vc_perp2vc)
angr = -2Pi bis +2Pi.
angr=0: pto = ln1.p1;
angr=1: pto = ln1.p2;
UT3D_pt_projpt2pt point = project point pt to line p1+p2 retcod 0=OK, 1=pt is on line, 2=Inputerror (vl too short) see also UT3D_pt_ck_ptvc UT3D_pt_ck_onLine UT3D_nlen_2ptvc UT3D_pt_projptptvc
UT3D_pt_projptln point = project point to line retcod 0=OK, 1=pt is on line.
UT3D_pt_projptci point = project point to circ
UT3D_pt_projptptvc point = project point pt to line pl+vl pl - vl gives a line, pt is projected onto this line. X pt | len| | pl------+--------vl pp retcod 0=OK, 1=pt is on line, 2=Inputerror (vl too short) E001 vl too short see also UT3D_pt_ck_ptvc UT3D_pt_ck_onLine UT3D_nlen_2ptvc UT3D_pt_projptptvc UT3D_pt_projptln
UT3D_pt_projptel proj PT -> CRV-Ellipse Project a point onto an ellipse. All possible cases are considered! IN: CurvElli *ell ... a 3D - ellipse Point *pt ... a 3D - point OUT: int *numpe ... number of points (0-4 points out) Point *pe ... points on the ellipse all having the same minimal distance to the input point Returncodes: 0 = OK 1 = input error
| int UT3D_pt_projptbspl | ( | int * | nxp, | |
| Point * | ptab, | |||
| double * | ttab, | |||
| Memspc * | memSeg1, | |||
| CurvBSpl * | bspl, | |||
| Point * | pt | |||
| ) |
UT3D_pt_projptptnvc project point pt to plane from Origin, Z-vec
UT3D_pt_projptpl point = project point to plane
see UPRJ_app_pt
| int UT3D_pt_int2pt2vc | ( | Point * | ip1, | |
| Point * | ip2, | |||
| double * | dist, | |||
| Point * | ptu, | |||
| Vector * | vcu, | |||
| Point * | ptv, | |||
| Vector * | vcv | |||
| ) |
UT3D_pt_int2pt2vc intersect 2 rays ip1 liegt auf ray1 (ptu/vcu) ip2 liegt auf ray2 (ptv/vcv) Returncodes: 0 = Lines parallel or zero-length 1 = OK; dist gives the minimum distance. 2 = OK; lines are crossing, ip1 = ip2, dist = 0.
UT3D_pt_intptvcplx intersect point/vector with Y-Z-plane irc 0 OK px = Schnittpunkt irc -1 kein Schnittpunkt (vl parallel pln)
UT3D_pt_intptvcply intersect point/vector with X-Z-plane irc 0 OK px = Schnittpunkt irc -1 kein Schnittpunkt (vl parallel pln)
UT3D_pt_intptvcplz intersect point/vector with X-Y-plane irc 0 OK px = Schnittpunkt irc -1 kein Schnittpunkt (vl parallel pln)
| int UT3D_pt_intptvcln | ( | Point * | ip1, | |
| Point * | ip2, | |||
| double * | dist, | |||
| Point * | pt1, | |||
| Vector * | vc1, | |||
| Line * | ln2 | |||
| ) |
UT3D_pt_intptvcln intersect ray - lineSegment ip1 liegt auf ray (pt1/vc1) ip2 liegt auf Line ln2 Returncodes: 0 = Lines parallel or zero-length 1 = OK; dist gives the minimum distance. 2 = OK; lines are crossing, dist=0, ip1=ip2, but outside lineSegment. 3 = OK; lines are crossing, dist=0, ip1=ip2 and inside lineSegment.
UT3D_pt_intptvcxpln intersect line(x-parallel) X plane (pt-vc) Input: ptl Point on line (direction of line = 1,0,0) ptpl Point in plane vcpl perpendicular Vector to plane (muss nicht normiert sein); Returncodes: 0 = OK 1 = no intersection (parallel) See also UT3D_ln_int2pl UT3D_ptvc_int2pl UT3D_pt_intptvcpl
UT3D_pt_intptvcypln intersect line(y-parallel) X plane (pt-vc) Input: ptl Point on line (direction of line = 0,1,0) ptpl Point in plane vcpl perpendicular Vector to plane (muss nicht normiert sein); Returncodes: 0 = OK 1 = no intersection (parallel) See also UT3D_ln_int2pl UT3D_ptvc_int2pl UT3D_pt_intptvcpl
UT3D_pt_intptvczpln intersect line(z-parallel) X plane (pt-vc) Input: ptl Point on line (direction of line = 0,0,1) ptpl Point in plane vcpl perpendicular Vector to plane (muss nicht normiert sein); Returncodes: 0 = OK 1 = no intersection (parallel) See also UT3D_ln_int2pl UT3D_ptvc_int2pl UT3D_pt_intptvcpl
UT3D_pt_intlnsph intersect unlimited line / sphere irc -1 Error (vl too short) irc 0 pl-vl outside sphere irc 1 touches - OK - 1 point out irc 2 OK, 2 points out. Richtung entspricht vl.
UT3D_pt_int2ln intersect 2 unlimitedLines; get 2 points & dist. IN: Line *ln1 line 1 Line *ln2 line 2 Point *ip1 NULL: do not compute ip1 double *dist NULL = do not compute dist OUT: Point *ip1 point on line 1; Point *ip2 point on line 2 double *dist minimal distance between ip1 and ip2 Returncodes: -1 = Lines parallel or zero-length 0 = OK; dist gives the minimum distance. 1 = OK; distance (ip1-ip2) is less than UT_TOL_pt
UT3D_pt_intperp2ln inters ln2 with perp.plane to ln1 Plane geht durch p1 normal auf v1; Schnittpunkt liegt auf p2/v2. po-p1 hat rechten Winkel zu p1-v1. see UT3D_pt_intptvcpl; pl.po=p1; pl.vz=v1; pt=p2, vln=v2. Returncodes: 0 = vc parallel to plane; Error 1 = OK; -1 = p1 und p2 ident; po = p1.
UT3D_pt_intlnci__ intersect line - circle (both unlimited) Intersection of line and circle. The line need NOT lie in the plane of the circle. IN: Line *ln ... 3D-line Circ *ci ... 3D-circle OUT: int *np ... number of intersection points (0,1,2) Point xp[] ... array of intersection points Returncodes: 0 = OK 1 = no intersection
UT3D_pt_intlnci_p intersection LN-CIR (both unlimited; 0/1/2 points) Intersection of 3D-line with 3D-circle. The line must lie in the plane of the circle. !! IN: Line *ln ... 3D-line Circ *ci1 ... 3D-circle OUT: int *np ... number of intersection points (0,1,2) Point xp[] ... array of intersection points Returncode: 0 = OK 1 = no intersection; xp[0]=pc projected -> ln
UT3D_pt_intlnsph intersect limited line / sphere irc -1 Line ganz ausserhalb
UT3D_pt_intcici intersect CIR CIR (gives 0/1/2 points) IN: Line *ln 3D-line Circ *ci1 3D-circle ci1Lim1 0=limited Circ, 1=unlimited Circ Circ *ci2 3D-circle ci1Lim2 0=limited Circ, 1=unlimited Circ OUT: Point pa[] array of intersection points; size 2 Returncode: -1 no intersection 1 1 intersectionpoint (pa[0]) 2 2 intersectionpoints (pa[0] and pa[1])
UT3D_pt_intplnln intersect LineSegment X Plane Von pl wird nur p und vz benutzt. Returncodes: -1 = LineSegment outside Plane 0 = vc parallel to plane 1 = OK; intersecting ... 2 = ip = ln.p1 3 = ip = ln.p2 intersect unlimited Line X Plane: UT3D_pt_intptvcpln see also UT3D_pt_intlnpl1 UT3D_ptDi_intptvcpln
UT3D_pt_intlnpl point = intersection of line - plane ln = unlimited line Returncodes: 0 = line parallel to plane 1 = OK;
intersect line - plane
OUT
pi Intersectionpoint
dl Faktor Abstand p1 - pi - p2; 0.5 ist genau in der Mitte.
IN
p1, p2 die Linie, die geschnitten wird
dn1 dn2 der Normalabstand der Punkte p1 p2 von der Schnittebene.
(get dn1 from UT3D_slen_ptpl)
pi liegt auf der Geraden p1;p2.
Die Plane wird ebenfalls als (hor-) Linie betrachtet.
pi ist intersection dieser beiden Lines.
dn. sind die NormalAbstaende von p1,p2 auf die Plane (=hor.Linie).
see also UT3D_pt_intplnln UT3D_ptDi_intptvcpln UT3D_pt_intptvcpln
UT3D_pt_intptvcpln intersect line-plane (pt-vc pt-vc) Line durch Point + Vektor Plane durch Nullpunkt + Normalvektor. pl2vz muss nicht normiert sein; See also UT3D_ln_int2pl UT3D_ptvc_int2pl UT3D_pt_intptvcpl Returncodes: 0 = OK 1 = no intersection (parallel) see also UT3D_pt_intplnln UT3D_pt_intlnpl1 UT3D_ptDi_intptvcpln
UT3D_pt_intplnci intersect PLN 360-deg-Circ IN: Plane *pl1 Plane Circ *ci 3D-circle ciLim 0=limited Circ, 1=unlimited Circ OUT: Point pa[] array of intersection points; size 2 Returncode: -2 = no intersection (parallel planes) -1 = no intersection (plane passes circle) pa[0]=cp.pc proj -> pl 1 = 1 intersectionpoint (circ touch plane) 2 = 2 intersectionpoints was UT3D_pt_intplci see also UT3D_pt_intcidpln
UT3D_pt_intcidpln intersect circ / perpend.offsetPlane unlimited circle only ! Ein Kreis (pc=Mittelpunkt, p1=Punkt am Kreis, vz=Achse) dx ist der Abstand der Plane vom pc. Eine Plane normal zur Kreisflaeche im Abstand von dx schneidet den Kreis. Z-Vektor der Plane ist pc-p1; der vz ist der X-vec der Plane. Origin der Plane ist ppo (Vom pc in Richtg p1 Abstand dx) Output: die beiden Schnittpunkte mit der Plane. np Anzahl Schnittpunkte (0/1/2)
UT3D_pt_intptvcpl_ point = intersection of pt / vc - plane Von pl wird nur p und vz benutzt. Returncodes: 0 = vc parallel to plane 1 = OK;
UT3D_pt_intlnel__ intersect line and ellipse Intersection of line and ellipse. The line need NOT lie in the plane of the ellipse. IN: Line *ln ... 3D-line CurvElli *el ... 3D-ellipse OUT: int *np ... number of intersection points (0,1,2) Point xp[] ... array of intersection points Returncodes: 0 = OK 1 = no intersection -1 = ellipse degenerated
UT3D_pt_intlnel_p intersection LN-ELL (gives 0/1/2 points) !! The line must lie in the plane of the ellipse. !! Intersection of 3D-line with 3D-ellipse. !! The line must lie in the plane of the ellipse. !! IN: Line *ln ... 3D-line CurvElli *el ... 3D-ellipse OUT: int *np ... number of intersection points (0,1,2) Point xp[] ... array of intersection points Returncodes: 0 = OK 1 = no intersection -1 = ellipse degenerated
UT3D_pt_ipl_2ptpt2 interpolate PointPosition for 2D-point Input: 2 3D-points and 1 2D-point (between the 3D-pt's; z-coord missing). Output: 3D-Point with interpolated Z-coord. see also UTP_param_p0p1px UTP_px_paramp0p1px
UT3D_pt_tangptci tangent from point to circ RetCod: Nr of solutions; -1,1,2. see UT3D_vc_tangci UT3D_vc_tangcipt
UT3D_pt_elfoc focal points of ellipse Computation of the focal points of an ellipse. IN: CurvElli *el ... 3D-ellipse OUT: Point *fp1 ... focal point 1 (in direction of main axis) Point *fp2 ... focal point 2 Returncodes: 0 = OK -1 = input error
UT3D_pt_evparln evaluate param.point on line einen Punkt auf Line ln1 errechnen; lpar = Abstandswert 0 - 1. lpar=0: pto = ln1.p1; lpar=1: pto = ln1.p2;
UT3D_pt_evparci evaluate param.point on circ einen Punkt auf Circ ci1 errechnen; lpar = Abstandswert 0 - 1. lpar=0: pto = ci1.p1; lpar=1: pto = ci1.p2;
UT2D_pt_traptm3 apply transformation to point (from 4x3-matrix) p2 und p1 duerfen ident sein
UT3D_pt_traptm3 apply transformation to point (from 4x3-matrix) p2 und p1 duerfen ident sein VX VY VZ Nullpunkt [0][0]=vx.dx [0][1]=vy.dx [0][2]=vz.dx [0][3]=o.x [1][0]=vx.dy [1][1]=vy.dy [1][2]=vz.dy [1][3]=o.y [2][0]=vx.dz [2][1]=vy.dz [2][2]=vz.dz [2][3]=o.z Mat via Adresse: printf(" vz=%f,%f,%f\n",(*mata)[0][2],(*mata)[1][2],(*mata)[2][2]);
UT3D_pt_traptm4 apply transformation to point (from 4x4-matrix) p1 in p2 out.
UT2D_ptvc_ck_int2pt check if Line|Ray Pt-Vec intersects Line Pt-Pt Line = both sides limited; Ray = one side unlimited. Input: mode = 0 p1s-v1: both sides unlimited; p2s-p2e: both sides limited. mode = 1 p1s-v1: one side unlimited; p2s-p2e: both sides limited. Returncodes: -1 = no intersection between unlimited Line p1s-v1 and segment p2s-p2e. 0 = OK; lines intersect. 1 = p1s-v1 goes tru p2s 2 = p1s-v1 goes tru p2e 3 = p1s-v1 and p2s-p2e are parallel; no intersection-checks yet ! 4 = p1s lies exact on p2s-p2e. (ONLY if mode=1) 5 = p1s and p2s are equal (ONLY if mode=1) 6 = p1s and p2e are equal (ONLY if mode=1)
UT3D_ptvc_int2pl point/vector = intersection of 2 planes Retcodes: 1 - OK 0 - no intersection; planes parallel Intersectionpoint is nearest point to both origins.
| int UT3D_ptvc_int2pln | ( | Point * | pti, | |
| Vector * | vci, | |||
| Point * | pl1pt, | |||
| Vector * | pl1vz, | |||
| Point * | pl2pt, | |||
| Vector * | pl2vz | |||
| ) |
UT3D_ptvc_int2pln point/vector = intersection of 2 planes Planes durch Nullpunkt und Normalvektoren. pl2vz muss nicht normiert sein; vci (out) ist normiert. See also UT3D_ln_int2pl UT3D_ptvc_int2pl UT3D_pt_intptvcpl Returncodes: 0 = OK 1 = no intersection (parallel planes)
UT3D_angr_2vcd angle between two vec's (always 0 <= PI)
UT3D_angr_3vc angle between 2 vectors; vz gives direction (pos|neg) RetCod: angle between v1 and v2; range from pi to -pi see UT3D_angr_2vc see UT3D_angr_cipt
| double UT3D_angr_ci | ( | Circ * | ci1 | ) |
UT3D_angr_ci opening angle of Circ ACHTUNG: nicht fuer Vollkreise !
| int UT3D_2angr_vc | ( | double * | az, | |
| double * | ay, | |||
| Vector * | vc1 | |||
| ) |
UT3D_2angr_vc 2 opening angels of vec (Y-ang = kipp, Z-ang = dreh) vc1 entspricht der X-Achse; dise wird so gedreht, dass dann vc1 Die Winkel sind so gesetzt, dass die X-Achse einer DL-Liste dann in Richtung vc1 zeigt. (soll Z-Achse benutzt werden: ay -= 90. degree.)
den Anstieg (tan) der Geraden vci bezueglich Ebene pli
vci muss nicht normiert sein
irc: 0 OK
irc: -1 vci ist normal auf die Plane pli
| int UT3D_compvc0 | ( | Vector * | v1, | |
| double | tol | |||
| ) |
UT3D_compvc0 compare vectors for 0,0,0. Retcode 0: v1 <> 0.0 (gr. oder kl. tol) 1: v1 = 0.0 (innerhalb tol) if(UT3D_compvc0 (&vz, UT_TOL_min0) == 1) printf("vec is 0,0,0 !\n");
UT3D_comp2vc compare 2 vectors for parallel and antiparallel tolerances: see func. UT3D_vc_ck_parpl RC=1: die Vektoren sind gleich. RC=0: die Vektoren sind unterschiedlich.
UT3D_comp2vc_p compare 2 vectors for parallel tolerances: see func. UT3D_vc_ck_parpl RC=1: die Vektoren sind gleich. RC=0: die Vektoren sind unterschiedlich. if(UT3D_comp2vc_p(&ciO.vz, &UT3D_VECTOR_IZ, UT_TOL_min1) != 0) gleich
UT3D_vc_ck_parpl check if vec is parallel to plane tol ca 0.1 (zB UT_TOL_cv tol 0.02 ist 1.15 Grad (bei Vec-Laenge 1 !) tol 0.01 ist 0.60 Grad (bei Vec-Laenge 1 !) tol 0.004 ist 0.23 Grad (bei Vec-Laenge 1 !) RetCode: 0 = vec is NOT parallel to plane 1 = vec is parallel to plane
UT3D_vc_ckperp_2vc1 check if 2 normalized-vectors are normal (perp.) For not-normalized vectors use UT3D_vc_ck_perpvc. tol entspricht etwa der Abweichung; 1 / 0.1 = Steigung 10 : 1; 0.1 ~ 5.7 deg, 0.01 ~ 0.5 deg .. RetCode: 0 = vc1 is NOT normal to vc2 1 = vc1 is normal to vc2
| int UT3D_vc_ck_std | ( | Vector * | vc1 | ) |
UT3D_vc_ck_std check for standardVector (DX DY DZ DIX DIY DIZ) RetCod: 0 not parallel to x, y, or z-vector 1 DX 2 DY 3 DZ -1 DIX -2 DIY -3 DIZ index: i = v; if(i < 0) i = 3 - i; // gives 1-6 DBindex: dbi = -i;
UT3D_parvc_2vcbp parameter of distance of vec1 projected on vec2 mainPln: Berechnungsebene BackPlane ex UT3D_bp_vcz. dl ist zwischen 0 bis 1; wenn dl=0.5 liegt der Endpunkt von V2 genau in der Mitte des Vektors V2. V1,V2 have same startpoint s. x /| / | V1 | / | / | s---------V2-------x dl
UT2D_2parvc_3vc project end of vec1 along vec2 on vec3 mainPln: Berechnungsebene BackPlane ex UT3D_bp_vcz. Zu gegebenen Vektoren v1, v2, v3 finden wir Zahlen x und y so, dass dx * v1 + dy * v3 = v2. dx/dy sind zwischen 0 bis 1; wenn dx=0.5 liegt der Endpunkt von V2 genau in der Mitte des Parallelogramss V1-V3. y \ V1,V2,V3 have same startpoint s. dy \-----------x \ / \ \ / \ V3 \ V2 \ \ / \ \ / \ s----------------------------x dx V1
| void UT3D_vc_2angr | ( | Vector * | , | |
| double | , | |||
| double | ||||
| ) |
UT3D_vc_2angr Vector = Angle_X_axis, Angle_Z_axis. angX = Drehwinkel, angZ = Kippwinkel.
UT3D_vc_2vc intermediate Vector Vektoren muessen normiert sein !!! Vektoren duerfen nicht antiparallel sein !! AusgabeVektor nicht normiert !
| int UT3D_vc_bp | ( | Vector * | vn, | |
| int | bp | |||
| ) |
UT3D_vc_bp returns normalVector from BackPlaneNr (0-2)
UT3D_vc_perp2vc vector = perpendic. to 2 vectors (crossprod CROSS) Liefert den Z-Vektor wenn v1=X-vec; v2=Y-vec. Get VZ from VX, VY: UT3D_vc_perp2vc (&vz, &vx, &vy); Get VY from VZ, VX: UT3D_vc_perp2vc (&vy, &vz, &vx); Get VX from VY, VZ: UT3D_vc_perp2vc (&vx, &vy, &vz); v1, v2 muessen nicht normiert sein. vp ist nicht normiert.
UT3D_vc_perpvc2pt vector = perpendic. to vec & 2 points (crossprod) Liefert den Z-Vektor von X-Vektor, Y-AchsStartpunkt und Y-AchsEndpunkt Get VZ from VX, PY1, PY2: UT3D_vc_perp3pt (&vz, &vx, &pya, &pye); Get VY from VZ, PX1, PX2: UT3D_vc_perp3pt (&vy, &vz, &pxa, &pxe);
UT3D_vc_perp3pt vector = perpendic. to 3 points (crossprod) Liefert den Z-Vektor von Origin, X-AchsEndpunkt und Y-AchsEndpunkt Get VZ from PO, PX, PY: UT3D_vc_perp3pt (&vz, &po, &px, &py); Get VY from PO, PX, PZ: UT3D_vc_perp3pt (&vy, &po, &pz, &px);
UT3D_vc_perp4pt vector = perpendic. to 2 lines (crossprod) Get VY from VZ, PX1, PX2: UT3D_vc_perp3pt (&vy, &vz, &pxa, &pxe);
UT3D_vc_perpvcplXY Normalvektor auf vc1, der in der X-Y-Plane liegt.
UT3D_vc_perppta Normalvektor auf planares Polygon
UT3D_vc_normalize change to length 1 vn = vc = OK.
UT3D_vc_setLength change vectorlength vco und vci duerfen ident sein use UT3D_vc_multvc with vectors of length=1
UT3D_vc_setLenLen change vectorlength; actLen known.
UT3D_vc_tangci vector to circ (0. - 1.) make tangent to circ at position u ACHTUNG: dzt nur 0. und 1. !!!
UT3D_vc_tangcipt tangent to point on circ
UT3D_vc_rotangr rotate a vector around Z-axis vco and vci can be the same adress
UT3D_vc_rot3angr rotate a vector (vco and vci can have the same adress)
UT3D_vc_rotvcvcangr rotate vec vi around vec va VA MUSS NORMIERT SEIN !!! see UT3D_pt_rotptptvcangr
UT3D_vc_projvcvc vector v3 = project vector v1 to vector v2 see UT3D_parvc_2vc RetCodes: 0 OK -1 v1-v2 aufeinander Normal; v3 ist Nullvektor. /| V1/ | / | / | / | V2 x----V3-->------------>
UT3D_vc_projvc2vc vector = project vector to plane from 2 vec's
UT3D_vc_projvcnvc project vec to plane from Z-vec den vi auf den vz projizieren; die Strecke Spitze-vi nach Spitze-vz ist der gesuchte vo. vo = vi - vz1 ^ /^ | vi/ | vo| / vo | / | | / | x--------+------------> VZ |---vz1-->
UT3D_vc_projvcpl vector = project vector to plane
UT3D_vc_travcm3 apply transformation to vector (from 4x3-matrix) rotate Vector: prepare with UT3D_m3_inirot b a may be ident
UT3D_vc_travcm4 apply transformation to vector (from 4x4-matrix) wird das ein normalisierter vektor ? eigentlich eine vectorTransform ? dann sollte a ein vc sein !
UT3D_comp2ln compare 2 lines if identical RC = 1 = Lines are identical RC = 0 = one of the points has a distance > tol
check if 2 lines collinear Input: l11, l12 Line 1 l21, l22 Line 2 Output: lo1, lo2 the collinear segment if RC==1 RetCod: -1 no 0 yes, no coverage 1 coverage: coverline out
UT3D_ln_ck_parpl check if line is parallel to plane UT3D_ln_ck_parpl Author: Thomas Backmeister 4.7.2003 Check, if a line is parallel to a plane. IN: Line *ln ... 3D-line Plane *pl ... plane double tol ... tolerance for parallelism OUT: double *dist ... signed distance line - plane if line || plane >0.0 <=> line ON side of plane normal vector <0.0 <=> line on OPPOSITE side of plane normal vector Returncodes: 0 = line is NOT parallel to plane 1 = line is parallel to plane
| void UT3D_ln_6db | ( | Line * | , | |
| double | , | |||
| double | , | |||
| double | , | |||
| double | , | |||
| double | , | |||
| double | ||||
| ) |
line from 2 * 3 doubles
UT3D_ln_int2pl LN = Intersection PLN / PLN Intersection of 2 planes. The 1. point of the intersection line is the closest to the coordinate origin. The 2. point of the intersection line has distance 1 to the 1. point. IN: Plane *pl1 ... 1. plane Plane *pl2 ... 2. plane OUT: Line *ln ... intersection line of the 2 planes Returncodes: 0 = OK 1 = no intersection (parallel planes)
UT3D_ln_tangcici Tangente (4 Lines) an CIR - CIR sNr = 1-4 RC = 0: OK; -1: keine Loesung moglich
UT3D_ln_parl2ln ln <== gemeinsame Strecke of 2 lines rc = -1: keine gemeinsame Strecke rc = 0: po1-po2 ist die gemeinsame Strecke
UT3D_ln_pts_dmax line <-- points with max. distance of pointTab. Computation of a line from a set of points. The line points will be such that their distance is maximal! Die am weitesten auseinanderliegenden Punkte suchen, Linie davon machen. IN: int np ... number of points Point *ptab ... points double tol ... tolerance: minimal desired distance between line points OUT: Line *ln ... line with maximal point distance Returncodes: 1: line exists 0: no line exists
change LineLength; center around pc
| void UT3D_ln_inv | ( | Line * | ln1 | ) |
Den Radius eines Kreises errechnen, von dem 3 Punkte bekannt sind.
p1-p3 sind 3 punkte am Kreis.
rc = a * b / 2 * hc - is halt so ..
pp2
/ | \
/ | \
b hc a
/ | \
pp3 -------c--------pp1
q p
| int UT3D_ck_ci180 | ( | Circ * | ci1 | ) |
UT3D_ck_ci180 check if circ is 180-degree-circ RC = 0: YES, is 180-deg-circ RC = 1: NO if(UT3D_ck_ci180 == YES) ...
| int UT3D_ck_ci360 | ( | Circ * | ci1 | ) |
UT3D_ck_ci360 check if circ is 360-degree-circ RC = 0: YES, is 360DegCirc RC = 1: NO if(UT3D_ck_ci360 == YES) ...
UT3D_ci_ptvcr Circ from center, axis, radius
UT3D_ci_pt2vcr Circ from center, axis, x-vec and radius
UT3D_ci_cip3 change start- and endpoint of circ
| int UT3D_ci_ciangr | ( | Circ * | ci, | |
| double | ao2 | |||
| ) |
UT3D_ci_ciangr change endpoint of circ from angle
| void UT3D_ci_setangr | ( | Circ * | ci1 | ) |
UT3D_ci_setangr fix angle from p1-p2
UT3D_ci_ptptvcangr Circ from center, startpoint, axis, opening angle neg. Winkel: CCW !
UT3D_ci_ptptvcrd Circ from startpoint endpoint radius Z-vector rd Radius; r>0 = CCW, r<0 = CW siz 1 0-180 deg siz -1 180-360 deg irc -1 p1 - p2 ident irc -2 Radius too small (p1-p2) > (rd * 2)
UT3D_ci_cipt180 change circ -> 180 deg-circ; keep dir make p2 opposit to p1
UT3D_ci_cipt360 change circ -> 360 deg-circ; keep dir
UT3D_ci_pcvzpt180 180 deg-circ (CCW) from center, axis, startpoint
| int UT3D_ptNr_ci | ( | Circ * | ci1, | |
| double | tol | |||
| ) |
UT3D_ptNr_ci nr of points for polygon from circle
| int UT3D_ci_inv1 | ( | Circ * | ci1 | ) |
UT3D_ci_inv1 invert (change p1, p2, dir) Kreis bleibt optisch ganz gleich !!
| int UT3D_ci_inv2 | ( | Circ * | ci1 | ) |
UT3D_ci_inv2 invert (change dir) KreisOut = Vollkreis - KreisIn (das Komplement)
| int UT3D_ci_inv3 | ( | Circ * | ci1 | ) |
UT3D_ci_inv3 invert (optisch gleich, Z-Axis invers)
UT3D_ci_ptvcrd Circ from startpoint, startvector, radius .. ACHTUNG: vs und vz muessen normiert sein ! Input: ps Startpoint of circ vs tangent in ps rd Radius; positiv:circ=ccw; negativ: circ=cw. vz Axis a1 Angle in rad; 0=full circle.
UT3D_ci_2ptvcrd Circ from 2 Points-on-Circ & Radius RetCod: nr of circles in cia see UT3D_ci_ptptvcrd UT3D_ci_ptvcrd d1 | vc1 x-----------x-----------x pp1 pt1 pp2 | | |vc2 | x circ.pc
UT3D_ci_3pt Circ from 3 points p1-p3 sind 3 punkte am Kreis. rc = a * b / 2 * hc - is halt so .. hx wird genau in Mitte von c angesetzt (Streckensymmetrale, Pt. pMc) hx = sqrt (r * r - (c * c / 4)) // gleichseitiges Dreieck p1,p2,Cen. pp2 / | \ / | \ b hc a / | \ pp3-------c--------pp1 q | hx,vx | Cen
UT3D_ci_ptptrd Circ = tangent to PT + PT, radius. DO NOT USE; use UT3D_ci_2ptvcrd
UT3D_ci_ciptrd Circ = tangent to CI + PT, radius. RetCod: -1 Error 0-2 Nr of resulting Circles
UT3D_ci_2lnrd Circ = corner for 2 Lines RC = -1: Lines parallel 0-4: nr of Circs generated
UT3D_ci_lncird Circ = tangent to CIR + CIR, radius. RC = 1,2 = Anzahl Kreise. -1 = keine Loesung
UT3D_ci_lncird Circ = tangent to LN + CIR, radius. Input: sNr solutionNr, -1 == alle Solutions, else nur die gewuenschte RC = 1,2,3,4,5,6,7,8 = Max. Anzahl Kreise.
| int UT3D_ci_ptrd2vc2angr | ( | Circ * | ci, | |
| Point * | pc, | |||
| double | rd, | |||
| Vector * | vz, | |||
| Vector * | vx, | |||
| double | a1, | |||
| double | a2 | |||
| ) |
circ from center, Radius, Z-Axis, X-Axis, startAngle, endAngle
ACHTUNG: Z-Axis u X-Axis muessen normiert sein !!!!
rd hat DrehRichtg.
ACHTUNG: die Winkel werden hier umgedreht, die Kreisdrehachse
ist genau verkehrt zum Plane-vz !
circ from center, point, axis, startAngle, endAngle
| int UT3D_ck_el360 | ( | CurvElli * | el1 | ) |
UT3D_ck_el360 check if elli is 360-degree-elli RC = 0: YES, is elli RC = 1: NO if(UT3D_ck_el360 == YES) ...
UT3D_angr_elpt parametric-Angle <- pt
| int UT2D_pt_elangd | ( | Point2 * | pto, | |
| double | lx, | |||
| double | ly, | |||
| double | angr | |||
| ) |
UT2D_pt_elangd pt <- parametric-Angle, rMaj, rMin. Einen Punkt auf der 2D-Ellipse aus einem Winkel errechnen. Der Winkel ist nur als Parameter zu sehen; eine Linie unter diesem Winkel schneidet nur den Innen- und Aussenkreis; nicht die Ellipse ! IN: angr = Winkel in rad, lx Laenge Hauptachse ly Laenge Nebenachse
UT3D_pt_elangd pt <- parametric-Angle.
| int UT3D_el_pt2vc2a | ( | CurvElli * | el, | |
| Point * | ptc, | |||
| Vector * | vcx, | |||
| Vector * | vcy, | |||
| double | a1, | |||
| double | a2, | |||
| int | idir | |||
| ) |
UT3D_el_pt2vc2a elli=center,vecMajAx,vecMinAx,AngStart,angEnd,dir. idir: CCW (0) od CW(1)
UT3D_el_projcipl ellipse = project CIR -> PLN Project a circle onto a plane. IN: Plane *pl ... projection plane Circ *ci ... 3D - circle OUT: CurvElli *el ... ellipse Returncodes: 0 = OK see also UPRJ_app_el
UT3D_el_projelpl ellipse = project ELL -> PLN see also UT3D_el_projcipl UPRJ_app_ci
| int UT3D_el_elcoe | ( | CurvElli * | , | |
| polcoeff_d5 * | , | |||
| Point2 * | pa, | |||
| Point2 * | pe, | |||
| double | zt | |||
| ) |
UT3D_el_elcoe Ellipse <-- coeff-data (IGES) ellipse from IGES-data of type 104. pa,pe Beginn/Endpunkt der Elli in 2D-Zentrumslage (Center ist 0,0) zt = Hoehe der Z-Plane der Elli im 2D IN: IgesConic *ig ... IGES-data of type 104 (conic arc entity) OUT: Ellipse Returncodes: 0 = OK and conic is ellipse -1 = input error: data are no conic arc entity
| int UT3D_elcoe_el | ( | polcoeff_d5 * | , | |
| CurvElli * | ||||
| ) |
UT3D_elcoe_el CoeffEllipse(IGES) <-- ellipse the ellipse lies in a plane parallel x,y-plane and its axes need not be parallel to x- resp. y- axis. IN: CurvElli *el ... ellipse in a plane parallel x,y-plane OUT: polcoeff_d5 ... IGES-coefficients of the ellipse equation Returncode: 0 = OK -1 = input error
testen ob alle Punkte planar (Abst. von Plane pPln-vc < UT_TOL_pt). RetCod = 0 OK, ist planer -1 no, 1-n points of pTab are not in plane pPln-vc
| int UT3D_rMin_pta | ( | double * | rMin, | |
| int | pNr, | |||
| Point * | pTab | |||
| ) |
vom gesamten Polgon den kleinsten Radius errechnen
Nur Abschaetzung; es wird von jeweils 3 Punkten der Kreisradius errechnet.
ev in eine neue source ../ut/ut_pta.c ?
UT3D_sr_polc nach Karl Sauer 2004-04-07 Umlaufsinn (sr=sense of rotation) eines geschlossenen 3D-Polygons (polc) berechnen. ptNr = Anzahl Punkte ohne den letzten == ersten Punkt ! pa = PunkteTabelle ohne den letzten == ersten Punkt ! RetCod = 1 = CCW -1 = CW mode: Berechnungsebene BackPlane ex UT3D_bp_vcz.
| int UT3D_pta_dbo | ( | Point ** | pTab, | |
| int * | pNr, | |||
| int | typ, | |||
| long | ind, | |||
| double | tol | |||
| ) |
UT3D_pta_dbo get polygon from DB-object(typ,ind) returns points in memspc201 ! (do not free)
Linearstueck -> Polygon.
In/Out: *ptAnz wird nur in 2 geandert, wenn < 2.
UT3D_npt_ci circular polygon see also UT3D_cv_ci
UT3D_cv_ci Polygon < 3D-Kreis IN: ptmax max. of outputpoints tol maximal deviation of secant; if(tol<0)then return fixed nr of points ptanz number of outputpoints (only if stol<0) OUT: Point cv[] ... array of polygonpoints; ptanz number of outputpoints
UT3D_cv_ell Polygon <- Ellipse Polygonial curve from 3D-Ellipse. IN: CurvElli *el ... 3D-ellipse int ptmax ... maximal number of polygonpoints double stol ... maximal deviation of secant; if(stol<0)then return fixed nr of points int *numpt ... number of outputpoints (only if stol<0) OUT: Point cv[] ... array of polygonpoints; if NULL: return only pointNr int *numpt ... number of polygonpoints Returncodes: 0 = OK 1 = ellipse is a line (va = 0) 2 = ellipse is a line (vb = 0) -1 = degeneration of ellipse (a = b = 0)
| int UT3D_cv_delia | ( | int * | pNr, | |
| Point * | pTab, | |||
| char * | ptStat | |||
| ) |
UT3D_cv_delia delete points out of pTab alle Punkte die (ptStat = 1) haben aus Tabelle loeschen pNr richtigstellen ptStat = 0: Punkt wird gebraucht ptStat = 1: Punkt loeschen
| int UT3D_cv3_linear | ( | int * | pNr, | |
| Point * | pTab, | |||
| double | tol | |||
| ) |
UT3D_cv3_linear delete unnecesary straight points alle Punkte die innerhalb tol liegen aus pTab entfernen.
| int UT3D_obj_dump | ( | ObjG * | el | ) |
UT3D_bp_2pt returns main-BackPlaneNr (0-2) from 2 points Hauptebene mit dem hoechsten Wert waehlen; zb fuer UT3D_parpt_lnbp
| int UT3D_bp_vc_ | ( | Vector * | ) |
UT3D_bp_vc_ returns main-BackPlaneNr (0-2) from vec eine Hilfsebene auswaehlen; Input ist ein Vektor; es wird jene Hauptebene mit dem hoechsten Wert gewaehlt. vc1 rc 1 0 0 1 = BCKPLN_XZ skip Y-Vec 0 1 0 2 = BCKPLN_XY skip Z-Vec 0 0 1 0 = BCKPLN_YZ skip X-Vec
| int UT3D_bp_vcz | ( | Vector * | ) |
UT3D_bp_vcz returns main-BackPlaneNr (0-2) from normalvec eine Hilfsebene auswaehlen; Input ist der Normalvektor der Ebene; es wird jene Hauptebene mit dem geringsten Wert gewaehlt. In: Out: 1,0,0 X-Vektor: 0 = BCKPLN_YZ es wird Y-Z-Plane gewaehlt; 0,1,0 Y-Vektor: 1 = BCKPLN_XZ es wird X-Z-Plane gewaehlt; 0,0,1 Z-Vektor: 2 = BCKPLN_XY es wird X-Y-Plane gewaehlt;
| void UT3D_pl_XYZ | ( | Plane * | pl1 | ) |
UT3D_pl_XYZ Defaultplane
| int UT3D_pl_bpdb | ( | Plane * | plo, | |
| int | bp, | |||
| double | dbc | |||
| ) |
UT3D_pl_3pt plane from 3 point's Achtung: für Transformation manchmal ungeeignet, weil der X-Vektor immer parallel zur XY_Ebene eingerichtet wird (use UT3D_pl_pt2vc).
plane from Origin, X-vec, Z-Vec. X-vec is fixed.
UT3D_pl_pt2vc plane from origin, X-vec, Y-Vec. X-vec is fixed. Both vecs are in the Plane !
UT3D_pl_ptvcpt Plane aus Nullpunkt, Z-Achse und Punkt auf X-Achse
UT3D_pl_ln make Plane from line Origin is line-center; Z-vec is line.
UT3D_pl_nobj plane fron ObjGX-table die Transformationsmatrix zu n Objekten suchen .. oTab enthaelt PT|LN|AC 1) Circ in den Inputdaten: vz auslesen, ptCen laden, Plane davon. 2) mind 2 Lines: vz=CrossProd. dazu; Origin = 1.Point, Plane davon. 3) von den InputObjekten eine Punktetabelle beladen; Plane davon.
| void UT3D_pl_invert | ( | Plane * | pl | ) |
UT3D_pl_invert Plane invert (change direction of Z-vec) Invert Z-Achse, swap X-Y-Achse.
UT3D_pl_rotpt rot. Refsys around Z; point gives new X-direction plo und pli duerfen gleich sein.
| int UT3D_pl_plcoe | ( | Plane * | pl, | |
| polcoeff_d3 * | co | |||
| ) |
UT3D_pl_plcoe plane <-- plane equation Computation of the plane from the coefficients of the plane equation. IN: polcoeff_d3 *co ... coefficients of plane equation OUT: Plane *pl ... plane Returncodes: 0 = OK -1 = input error
| int UT3D_plcoe_pl | ( | polcoeff_d3 * | co, | |
| Plane * | pl | |||
| ) |
UT3D_plcoe_pl plane equation <-- plane Computation of the coefficients of the plane equation to a plane, i.e. a, b, c, d such that a*X + b*Y + c*Z = d; IN: Plane *pl ... plane OUT: polcoeff_d3 *co ... coefficients of plane equation Returncodes: 0 = OK
| void UT3D_pl_p | ( | Plane * | pl | ) |
UT3D_pl_p plane - update p after a change of po or vz
| double UT3D_plg_lvTab | ( | double * | lvTab, | |
| Point * | pta, | |||
| int | ptNr | |||
| ) |
Box mit point vergroessern.
init Box zB mit UT3D_box_ini0
UT2D_rect_pts bounding rectangle <-- 2D-points Computation of a minimal axis-parallel rectangle which contains all given 2D-points. The rectangle is given by the endpoints of its diagonal. If all points ly on a line parallel x-, y- or z- axis, the rectangle will be a line segment. IN: int nump ... number of 2D-points Point2 *ptab ... 2D-points OUT: Point2 *pmin ... endpoint 1 of rectangle diagonal (lower left) Point2 *pmax ... endpoint 2 of rectangle diagonal (upper right) Returncodes: 0 = OK -1 = input error
| int UT3D_cv_boxxy | ( | Point * | pb1, | |
| double | x1, | |||
| double | x2, | |||
| double | y1, | |||
| double | y2 | |||
| ) |
UT3D_cv_boxxy load rect.points from xmin/xmax ymin/ymax in z=0
Box mit point vergroessern.
init Box zB mit UT3D_box_ini0
UT3D_box_2pt make box of 2 points
UT3D_box_2pttol make box of 2 points + tol
UT3D_box_pts bounding box <-- points Computation of a minimal axis-parallel box which contains all given points. The box is given by the endpoints of its diagonal. If all points ly in a plane parallel x,y-plane, the box will be a rectangle. IN: int nump ... number of points Point *ptab ... points OUT: Point *pmin ... endpoint 1 of box diagonal Point *pmax ... endpoint 2 of box diagonal Returncodes: 0 = OK -1 = input error
UT3D_box_tria make box from triangle
UT3D_box_addTol add tolerance to box
UT3D_ck_ptInBox check if point px is inside box p1-p2 box should have tolerance added; use UT3D_box_addTol RC = 0: YES, p is inside box p1 / p2 RC = 1: NO, p is outside box p1 / p2
check if 2 boxes overlap p1-p2 sind Box1, p3-p4 Box2. ACHTUNG: p1 muss links unter p2 liegen; p3 links unter p4. Toleranzen: schon zur Box dazuaddieren. RC -1: NO, boxes do not overlap RC 1: yes boxes overlap.
UT3D_box_ck_intLn check line-X with axis-parallel box Check if a line intersects an axis-parallel box. IN: Line *ln ... line Point *pmin ... endpoint 1 of box diagonal Point *pmax ... endpoint 2 of box diagonal double tol ... tolerance for line intersecting box (>0) OUT: Returncodes: 0 = the line does not intersect the box 1 = the line intersects the box
UT3D_box_ck_intpl check intersect. Plane / Box (estimate!) ACHTUNG: dzt nur rasche Abschaetzung !!! Returncodes: 0 = plane does not intersect the box 1 = plane intersects the box
| int UT3D_rbox_loadxy | ( | Point * | pb1, | |
| double | x1, | |||
| double | x2, | |||
| double | y1, | |||
| double | y2 | |||
| ) |
UT3D_ptvc_intbox intersect point/vector with box Input: pl ist ausserhalb box. vl zeigt in die box hinein. Output: pl ist der Schnittpunkt mit der am naechsten liegenden Boxplane.
UT3D_ln_intbox relimit line inside box Line an Raumbox begrenzen
define rotation (axis, origin angle)
UT3D_m3_loadpl load Plane(=Achsensystem) into 4x3 Transform.Matrix
UT3D_m3_load define refSys from 3 vectors (4x3 Matrix). Die Inp.Vec. muessen nicht normiert sein. use (translate points) with UT3D_pt_traptm3
UT3D_m3_load_povxvy neues Achsensystem mit Origin,vx,vy definieren
UT3D_m3_load_povxvz neues Achsensystem mit Origin,vx,vz definieren Doku see UT3D_m3_load
UT3D_m3_load_o Nullpunkt into 4x3 Transform.Matrix. Nach UT3D_m3_load.
UT3D_m3_invm3 4x3-Matrix invertieren ACHTUNG: Adresse darf NICHT gleich sein !!
UT3D_m3_multm3 4x3-Matrix mit 4x3 Matrix multiplizieren (nur den 3x3-Anteil)
UT3D_m3_tram3m3 apply transformation to Mat_4x3 see also UTRA_app__
| void UT3D_m4_init | ( | Mat_4x4 | ma | ) |
UT3D_m4_init Initialize a 4x4 - matrix Fuer horiz u vert matrix. ! ( 1 0 0 0 ) ( 0 1 0 0 ) [a] = ( 0 0 1 0 ) ( 0 0 0 1 )
| void UT3D_m4_init_ori | ( | Mat_4x4 | ma, | |
| double | px, | |||
| double | py, | |||
| double | pz | |||
| ) |
UT3D_m4_init_ori Initialize a 4x4 - matrix with translation hor. Matrix ! Mat_4x4-horizontal: Der erste Wert ist der Index ins double-Array. VX 0=[0][0]=vx.x 1=[0][1]=vx.y 2=[0][2]=vx.z 3=[0][3]=0 VY 4=[1][0]=vy.x 5=[1][1]=vy.y 6=[1][2]=vy.z 7=[1][3]=0 VZ 8=[2][0]=vz.x 9=[2][1]=vz.y 10=[2][2]=vz.z 11=[2][3]=0 PO 12=[3][0]=o.x 13=[3][1]=o.y 14=[3][2]=o.z 15=[3][3]=1
UT3D_m4_init_rot Initialize a 4x4 - matrix with rotation
UT3D_m4_loadpl load Plane(=Achsensystem) into 4x4 Transform.Matrix kann fuer glMultMatrixd verwendet werden.
UT3D_m3_load_o set origin into 4x4 Transform.Matrix.
UT3D_m4_addrot Concatenate 2 4x4 - matrixes.
| void UT3D_m4_addtra | ( | Mat_4x4 | ma, | |
| double | px, | |||
| double | py, | |||
| double | pz | |||
| ) |
UT3D_m4_addtra add a translation into 4x4-matrix
| double UT3D_sbs_ck_planar | ( | SurBSpl * | su1 | ) |
| double UT3D_sru_ck_planar | ( | ObjGX * | ru1 | ) |
| double UT_TOL_pt |
identical Points-tolerence
| double UT_TOL_cv |
max deviation from curve (distance analyticalCurve -> Curvepoint)
| double UT_TOL_ln |
max deviation of a point from a line
| double UT_DISP_cv |
max deviation from curve (distance analyticalCurve -> displayPolygon)
| double UT_TOL_min0 |
| double UT_TOL_min1 |
| double UT_TOL_min2 |
| double UT_TOL_PAR |
tolerance for parallelism
| double UT_TOL_Ang1 |
tolerance for Angle 0.01 Grad
| const double UT_VAL_MIN |
| const double UT_VAL_MAX |
| const double UT_DB_LEER |
| const double UT_DB_NULL |
| const int UT_INT_MAX |
| const int UT_I2_MAX |
| const char UT_CHR_NULL |
| const Point2 UT2D_PT_NUL |
| const Point UT3D_PT_NUL |
| const Vector2 UT2D_VECTOR_NUL |
| const Vector2 UT2D_VECTOR_X |
| const Vector2 UT2D_VECTOR_Y |
| const Vector UT3D_VECTOR_NUL |
| const Vector UT3D_VECTOR_X |
| const Vector UT3D_VECTOR_Y |
| const Vector UT3D_VECTOR_Z |
| const Vector UT3D_VECTOR_IX |
| const Vector UT3D_VECTOR_IY |
| const Vector UT3D_VECTOR_IZ |
| const Mat_3x3 UT3D_MAT_3x3 |
| const Mat_4x3 UT3D_MAT_4x3 |
| const Mat_4x4 UT3D_MAT_4x4 |
1.6.3