home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 13 / 13.iso / p / p024 / 16.img / AME3.LIB / OFFSOL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-17  |  56.1 KB  |  2,337 lines
  1. /* Next available MSG number is 65 */
  2.  
  3. /*************************************************************************
  4. Name: offsol.c.  AME2_APLIB_SAMP_offsol.c
  5.  
  6. Description: AME/API sample program for region-based offsetting 
  7.  
  8. Author: Japan/Eagle Group
  9.         Autodesk, Inc.
  10.  
  11.  
  12.  
  13.  
  14. Copyright (C) 1992 by Autodesk, Inc.
  15. /*************************************************************************
  16. *  
  17. *    Permission to use, copy, modify, and distribute this software
  18. *    for any purpose and without fee is hereby granted, provided
  19. *    that the above copyright notice appears in all copies and that
  20. *    both that copyright notice and this permission notice appear in
  21. *    all supporting documentation.
  22. * 
  23. *    THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED
  24. *    WARRANTY.  ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR
  25. *    PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.
  26. *
  27. *                                                                        *
  28. *    Offsetting is the heart of machining/milling. The OFFSET command in *
  29. *    AutoCAD is unpredictable for regions with concavities and for large * 
  30. *    shrink distances This program allows the user to take advantage of  *
  31. *    the region modeler in AME2.0 to solve these problems and offer a    *
  32. *    better machining environment. This sample program only deals with   *
  33. *    polylines with out arcs but can be extended to address them. Since  *
  34. *    the objective of the routine is also to demonstrate the power of    *
  35. *    region modeler the intermediate region operations are left visible. *
  36. *    If desired, the region processes can be made transparent by a ghost *
  37. *    script.                                 *
  38. *                                      *
  39. *    Two commands "SOLOFF" and "SOLMAC"                     *
  40. *    are available in this implementation.                               *
  41. *                                                                        *
  42. *    The command syntax for "SOLOFF" is shown as follows:                *
  43. *                                                                        *
  44. *          Command: soloff                                               *
  45. *          Offset distance <0.1000000>: Enter a value or RETURN          *
  46. *          Shrink/Expand<s>: Enter 'e' for expand or RETURN foe shrink   *
  47. *          Select a closed polyline of lines (only) to offset:           * 
  48. *            Pick a non self-intersecting closed polyline consisting     *
  49. *                                                      of lines only     *
  50. *                                                                        *
  51. *    The selected entity has to be closed polyline. This command         * 
  52. *    disallows large shrink distances resulting in NULL objects.         *
  53. *                                                                        *
  54. *    OFFSOL command lets you offset a closed polyline with a given       * 
  55. *    distance. This command is mainly implemented for NC tool path       * 
  56. *    generation. Shrinking is the main consideration but expansion also  * 
  57. *    should work. The polyline is decomposed into a region CSG (with     * 
  58. *    convex hulls) as primitives. Each primitive is then offset and      * 
  59. *    combined through the tree to give consistent                 * 
  60. *    offsetting. The resulting region is converted to a polyline and     * 
  61. *    displayed. The software can be modified for specific requirements   * 
  62. *    and other applications.                         *
  63. *                                                                        *
  64. *    The command syntax for "SOLMAC" is shown as follows:                *
  65. *                                                                        *
  66. *          Command: solmac                                               *
  67. *          Enter the diameter of tool <0.100000>: Enter a value          *
  68. *          Select a closed polyline of lines (only) to offset:           * 
  69. *            Pick a non self-intersecting closed polyline consisting     *
  70. *                                                      of lines only     *
  71. *                                                                        *
  72. *    For very large tool diameters which need only one pass to machine   * 
  73. *    the polyline, a message appears and no offsets are generated.       *
  74. *                                                                        *
  75. *    SOLMAC command lets you create tool paths recursively till the      * 
  76. *    whole 2d - solid is milled off. It uses the above offsol command    * 
  77. *    recursively with the shrink option and offset distance equal to the * 
  78. *    tool diameter. A circle representing the tool is created and        * 
  79. *    traversed over the current polyline. The final offset distance is   * 
  80. *    reduced, if needed, from tool diameter to tool radius to accomplish *
  81. *    complete machining. If multiple loops result in the offsetting,     * 
  82. *    each loop is machined fully before the next loop is machined, for   * 
  83. *    maximum efficiency.                                                 *
  84. *                                                                        *
  85. *    The offset distance, tool diameter and the shrink or expansion     * 
  86. *    option mentioned for the above commands use the previous selection  * 
  87. *    values as current defaualt values.                                  * 
  88. *    Since the above commands use AutoCAD's offset command on convex     *
  89. *    hulls and entity selection through points the program centers the   *
  90. *    object and sets proper zoom and limits. The current view and confi- *
  91. *    guration is saved   and restored at the end of offsetting.          *
  92. *                                                                        *
  93. *    It must be kept in mind that the program gives unexpected results   *
  94. *    for such cases when the entity is not parallel to UCS.              * 
  95. *                                                                        *
  96. *    You may want to take a look at code around *FHACK* for more         *
  97. *    robustness.                                                         *
  98. *                                                                        *
  99. *                                                                        *
  100. **************************************************************************
  101.  
  102. Modification history:
  103.     Refer to the RCS section at the end of this file.
  104.  
  105. Bugs and restrictions on use:
  106.  
  107. Notes:
  108.  
  109. **************************************************************************/
  110.  
  111.  
  112. /*************************************************************************/
  113. /* Includes */
  114. /*************************************************************************/
  115.  
  116. #include <stdio.h>
  117. #include <string.h>
  118. #include <math.h>
  119. #include <adslib.h>
  120. #include <aplib.h>
  121.  
  122. /*************************************************************************/
  123. /* Defines */
  124. /*************************************************************************/
  125.  
  126. #define PI 3.1415926
  127. #define ASPI 3.14159265358979323846
  128. #define AS2PI 2.0*3.14159265358979323846
  129. #define ASPI_2 3.14159265358979323846/2.0
  130. #define OP_DIF -1
  131. #define OP_UN 1
  132. #define ueps1 0.0008 /* different epsilons used throught the code */
  133. #define nueps 1.3258789e-4
  134. #define TRUNC_EPS 0.000001
  135. #define EXT_EPS 0.00001
  136. #define f_abs(a) ((a) >= 0.0 ? (a) : -(a))
  137. #define c_reqa(x, y, z) (f_abs(*(x) - *(y)) < *(z))
  138. #define NELEM(a)        (sizeof a  / sizeof a[0])
  139. #define Cpoint(ptd, pts)  ptd[X] = pts[X]; ptd[Y] = pts[Y]; ptd[Z] = pts[Z]
  140.  
  141. #ifndef ELEMENTS
  142. #define ELEMENTS(array) (sizeof(array)/sizeof((array)[0]))
  143. #endif
  144.  
  145. /*************************************************************************/
  146. /* Typedefs */
  147. /*************************************************************************/
  148.  
  149. typedef struct plypts           /* polyline points */
  150. {
  151.         double x;               /* x - cord */
  152.         double y;               /* y - cord */
  153.         double bg;              /* bulge for arc */
  154. } Ppts, *ppts;
  155.  
  156. typedef struct vertex           /* vertex info. */
  157. {
  158.     double  x;                  /* x-cord */
  159.     double  y;                  /* y-cord */
  160.     double bg;                  /* bulge for arc */
  161.     short flag;         /* additional info about line from this vtx to next */
  162.     struct vertex  *nxt;        /* ptr to next vertex */
  163. }                       Vertex, *Vptr;/* vertex pointer */
  164.  
  165. typedef struct
  166. {
  167.         double x;
  168.         double y;
  169. } Point;
  170.  
  171. typedef struct trenod           /* treenode info. */
  172. {
  173.     short     op;                       /* operation code (-1=>dif, 1=>un) */
  174.     struct trenod  *rht;        /* ptr to right son */
  175.     struct trenod  *lft;        /* ptr to left  son */
  176.                     Vptr vtx;   /* ptr to vertex data */
  177.     long   idx;         /* index to be transferred */
  178.     long  id;           /* solid id */
  179. }   Trenod, *Tnptr;/* treenod pointer */
  180.  
  181. typedef struct store            /* to store processing info. */
  182. {
  183.     Trenod * ptr;               /* Treenod pointer to be processed */
  184.     Trenod * pid;               /* Usually left son */
  185.     struct store   *nxt;        /* ptr to next stored data */
  186. }   Store, *Stptr;/* storage ptr */
  187.  
  188. typedef struct line
  189. {
  190.         double x1, y1;         /* first point */
  191.         double x2, y2;         /* second point */
  192.         double a, b, c;        /* coefficients of equation */
  193.         double len;             /* length */
  194.         struct line *li_next;
  195.         struct line *li_prev;
  196. } Line;
  197.  
  198. typedef struct ents
  199. {
  200.     ads_name ename;        /* entity name */
  201.     struct ents *nxt;      /* next one */ 
  202. } Ents, *Entsp;
  203.  
  204. /*************************************************************************/
  205. /* Global variables */
  206. /*************************************************************************/
  207.  
  208. char name[32];                        /* current layer name */
  209. ads_point vec;                  /* 210 vec for ECS */
  210. ads_real off_dist = 0.1;          /* default offset distance */
  211. short is_exp = -1;              /* default shrink option */ 
  212. ads_name tool_name;              /* entity name for tool */
  213. struct resbuf *tool_buf;          /* resbuf for tool ent. */
  214. int is_tool = 0;
  215. static ads_real cen[2], plim[2], fsp[2], snd[2]; /* XXXX */
  216. static Stptr sb, scur;                /* ptrs to base and current storage */
  217. static Tnptr root;                    /* ptr to root */
  218. static double z1,z2,theta;            /* bounding faces for ext. & rev. ang */
  219. static Vptr vi;                       /* ptr to initial vertex */
  220. static short dirn, i2, quat;
  221. long totpts;                          /* total number of points */
  222. static long glob;                    /* do boolean */
  223.  
  224. /* Function type declaration */
  225.  
  226. void off_sol();
  227. void mac_sol();
  228. short requal();
  229. long mknbl();
  230. /*
  231.  *  Define forward references for HighC compiler
  232.  */
  233. Tnptr treealloc();
  234. #if HIGHC386 || sun4 || __ZTC__
  235. void *malloc();
  236. #else
  237. char *malloc();
  238. #endif
  239. static int funcload();
  240. static  void print_new_command_set();
  241.  
  242. /* Command definition and dispatch table.  */
  243.  
  244. struct ads_comm {
  245.     char   *cmdname;
  246.     void   (*cmdfunc) ();
  247. };
  248.  
  249. struct ads_comm cmdtab[] = {
  250.         {/*MSG1*/"C:SOLMAC", mac_sol},
  251.         {/*MSG2*/"C:SOLOFF", off_sol},
  252.     };
  253.  
  254. /*************************************************************************/
  255. /* .doc main() */
  256. /*+
  257. -*/
  258. /*************************************************************************/
  259.  
  260. void
  261. /*FCN*/main(argc, argv)
  262.   int             argc;
  263.   char           *argv[];
  264. {
  265.     int             stat, cindex;
  266.     short           scode = 1;
  267.  
  268.     ads_init(argc, argv);
  269.  
  270.     while (TRUE) {
  271.         if ((stat = ads_link(scode)) < 0) {
  272.             printf(/*MSG3*/"OFFSOL: bad status from ads_link() = %d\n",stat);
  273.             fflush(stdout);
  274.             ads_exit(1);
  275.         }
  276.         scode = -RSRSLT;
  277.  
  278.         switch (stat) {
  279.         case RQXLOAD:                 /* Load & register functions */
  280.             scode = -(funcload() ? RSRSLT : RSERR);
  281.             scode = -RSRSLT;
  282.             print_new_command_set();
  283.             break;
  284.  
  285.         case RQXUNLD:                 /* Unloading */
  286.             scode = (funcunload ()  ? RSRSLT : RSERR);
  287.             ads_printf (/*MSG4*/"Unloading: ");
  288.             break;
  289.  
  290.         case RQSUBR:                  /* Evaluate external lisp function */
  291.             cindex = ads_getfuncode();
  292.             (*cmdtab[cindex].cmdfunc) ();
  293.             break;
  294.  
  295.         default:
  296.             break;
  297.  
  298.         }
  299.     }
  300. }
  301.  
  302. /*************************************************************************/
  303. /* .doc funcload() */
  304. /*+
  305.    Load external functions into AutoCAD system
  306. -*/
  307. /*************************************************************************/
  308.  
  309. static ap_Bool
  310. /*FCN*/funcload()
  311.  
  312. {
  313.     int             i;
  314.  
  315.     for (i = 0; i < ELEMENTS(cmdtab); i++) {
  316.         if(! ads_defun (cmdtab[i].cmdname , i))
  317.             return  RTERROR;
  318.     }
  319.     return RTNORM;
  320. }
  321.  
  322. /*************************************************************************/
  323. /* .doc funcunload() */
  324. /*+
  325.    Unload registered functions from AutoCAD system
  326. -*/
  327. /*************************************************************************/
  328.  
  329. static ap_Bool
  330. /*FCN*/funcunload()
  331.  
  332. {
  333.     int             i;
  334.  
  335.     for (i = 0; i < ELEMENTS(cmdtab); i++)
  336.         ads_undef(cmdtab[i].cmdname, i);
  337.  
  338.     return RTNORM;
  339. }                                     /* funcunload */
  340.  
  341. /*************************************************************************/
  342. /* .doc print_new_command_set() */
  343. /*+
  344. -*/
  345. /*************************************************************************/
  346.  
  347. static  void
  348. /*FCN*/print_new_command_set()
  349. {
  350.     ads_printf(/*MSG5*/"\nNew loaded commands: SOLOFF, SOLMAC\n");
  351. }
  352.  
  353. /*  
  354.  *    Print out the entity data similar to dxf format
  355.  */
  356.  
  357. void off_sol()
  358. {
  359.     ads_name e1;
  360.     ads_point pt;
  361.     char cmd[8], prompt[64];
  362.     int result;
  363.     Entsp done, do_proc();
  364.     
  365.  
  366.     if (ap_init() != AP_NORMAL)
  367.         return;
  368.     is_tool = 0;
  369.     sprintf (prompt, /*MSG6*/"Offset distance <%f>:", off_dist);
  370.     ads_initget (2+4, NULL); /* allow only positive values */
  371.     if (ads_getdist (NULL, prompt, &off_dist) == RTCAN)
  372.         return;
  373.     if (is_exp == 1)
  374.         sprintf (prompt, /*MSG7*/"Shrink/Expand<e>:");
  375.     else
  376.         sprintf (prompt, /*MSG8*/"Shrink/Expand<s>:");
  377.     ads_initget(0, /*MSG9*/"Shrink Expand");
  378.     result = ads_getkword(prompt, cmd);
  379.     if (result < 0)
  380.         return;
  381.     if (strcmp(cmd, /*MSG10*/"Shrink") == 0)  
  382.         is_exp = -1;
  383.     if (strcmp(cmd, /*MSG11*/"Expand") == 0)  
  384.         is_exp = 1;
  385.     /* default is_exp = 1 */
  386.     ads_entsel(/*MSG12*/"Select closed polyline of lines (only) to offset:", e1, pt);
  387.     /*
  388.     ads_entsel("Select closed polyline to offset:", e1, pt);
  389.     */
  390.     done = do_proc(e1);
  391.     return;
  392. }
  393.  
  394. /*
  395.  *  Search a result buffer chain and return an item
  396.  *  associated with the specified group code.
  397.  */
  398.  
  399. struct resbuf
  400. /*FCN*/*assoc_rb(rb, grp)
  401.   struct resbuf *rb;
  402.   int grp;
  403. {
  404.     while ((rb != NULL) && (rb->restype != grp))
  405.         rb = rb->rbnext;
  406.     return rb;
  407. }
  408.  
  409. off_err()
  410. {
  411.     ;
  412.     /*
  413.     ads_printf ("Error in off_setting\n");
  414.     */
  415. }
  416.  
  417. /* prepare data for main offsetting routine */
  418.  
  419. Entsp 
  420. do_proc(e1)
  421. ads_name e1;
  422. {
  423.      struct resbuf *ebuf, *eb, *eb2, *assoc_rb(), cb, rb, lb1, lb2;
  424.         ads_name  e2;
  425.         ads_point pt;
  426.         char cmd[8], prompt[64];
  427.         int result;
  428.         int cntr = 0, numvert = 0; /* count the number of verts */
  429.         int cmdecho;
  430.     Entsp  done, e_proces();
  431.         Ppts *ed;
  432.     ap_Objid obj;
  433.     Entsp cde, obj2ply();
  434.     ads_point lmn, lmx, p, pl;
  435.     short closed = FALSE, frst = TRUE;
  436.     ads_real eps = (ads_real)TRUNC_EPS;
  437.  
  438.     p[2] = lmn[2] = lmx[2] = 0.0;
  439.     ebuf = ads_entget(e1);
  440.     if (!ebuf)
  441.         return (Entsp)NULL;
  442.     eb = assoc_rb(ebuf, 0);
  443.     if (strcmp(eb->resval.rstring, /*MSG0*/"POLYLINE") != 0)
  444.     {
  445.         ads_printf(/*MSG13*/"The entity has to be a polyline\n");
  446.         return (Entsp)NULL;
  447.     }
  448.     eb = assoc_rb(eb, 8);  /* get the layer name */
  449.     sprintf (name, eb->resval.rstring);
  450.     eb = assoc_rb(eb, 210); /* get the ECS vec */
  451.     Cpoint (vec, eb->resval.rpoint);
  452.     eb = assoc_rb(ebuf, 70);
  453.     if (eb->resval.rint & 8)
  454.     {
  455.         ads_printf
  456.         ("\nNot a polyline. 3D polyline can not be offset\n");
  457.         return (Entsp)NULL;
  458.     }
  459.     else if (eb->resval.rint & 16)
  460.     {
  461.         ads_printf
  462.         ("\nNot a polyline. 3D mesh can not be offset\n");
  463.         return (Entsp)NULL;
  464.     }
  465.     else if (eb->resval.rint > 1)
  466.     {
  467.         ads_printf
  468.         (/*MSG14*/"\nNot a closed polyline of lines. Entity can not be offset\n");
  469.         return (Entsp)NULL;
  470.     }
  471.     else if (eb->resval.rint == 1)
  472.         closed = TRUE;
  473.     eb = assoc_rb(ebuf, 75);
  474.     if (eb && eb->resval.rint > 0)
  475.     {
  476.         ads_printf(/*MSG15*/"Not a polyline of lines. Entity can not be offset\n");
  477.         return (Entsp)NULL;
  478.     }
  479.     ads_relrb(ebuf);
  480.     if (is_tool) /* machine outer boundary */
  481.     {
  482.         if (ap_solidify(e1, &obj) != AP_NORMAL)
  483.             off_err();
  484.         cde = obj2ply(e1, obj, FALSE);
  485.         dump_ent(cde);
  486.     }
  487.  
  488.     ads_getvar(/*MSG0*/"CMDECHO", &cb);
  489.     cmdecho = cb.resval.rint;
  490.     cb.resval.rint = 0; /* turn the commands off */
  491.     ads_setvar(/*MSG0*/"CMDECHO", &cb);
  492.     ads_command (RTSTR, /*MSG16*/"_.VIEW", RTSTR, /*MSG17*/"_S", RTSTR,
  493.     /*MSG18*/"off_set", NULL);
  494.     ads_command (RTSTR, /*MSG20*/"_.PLAN", RTSTR, "", NULL);
  495.  
  496.     e2[0] = e1[0]; e2[1] = e1[1];
  497.     while (ads_entnext(e2, e2) == RTNORM)
  498.     {
  499.         ebuf = ads_entget(e2);
  500.         eb = assoc_rb(ebuf, 0);
  501.         if (strcmp (eb->resval.rstring, /*MSG0*/"VERTEX") == 0)
  502.         {
  503.             cntr++;
  504.             eb = assoc_rb(eb, 42);
  505.             if (eb && eb->resval.rreal)  /* arc or circle */
  506.             {
  507.                 ads_printf
  508.                 (/*MSG20*/"\nArcs and circles are not supported in this version\n");
  509.                 return (Entsp)NULL;
  510.             }
  511.             pl[0] = eb->resval.rpoint[X];
  512.             pl[1] = eb->resval.rpoint[Y];
  513.             if (!closed && frst)
  514.             {
  515.                 p[0] = pl[0];
  516.                 p[1] = pl[1];
  517.                 frst = FALSE;
  518.             }    
  519.         }
  520.         else /* SEQEND */
  521.         {
  522.             ads_relrb(ebuf);
  523.             if (!closed)
  524.             {
  525.                 if ((c_reqa(&pl[0], &p[0], &eps)) && (c_reqa(&pl[1], &p[1], &eps)))     
  526.                 {
  527.                     closed = 2;    
  528.                     cntr--;
  529.                 }
  530.                 else
  531.                 {
  532.                     ads_printf
  533.                     (/*MSG14*/"\nNot a closed polyline. Entity can not be offset\n");
  534.                     return (Entsp)NULL;
  535.                 }
  536.                 
  537.             }
  538.             break;
  539.         }
  540.     } 
  541.  
  542.     if((ed = (Ppts *)malloc(sizeof(struct plypts) * cntr)) == NULL)
  543.                 off_err();
  544.     
  545.     frst = TRUE; numvert = cntr;
  546.     cntr = 0;
  547.     e2[0] = e1[0]; e2[1] = e1[1];
  548.     while (ads_entnext(e2, e2) == RTNORM)
  549.     {
  550.         ebuf = ads_entget(e2);
  551.         eb = assoc_rb(ebuf, 0);
  552.         if (strcmp (eb->resval.rstring, /*MSG0*/"VERTEX") == 0)
  553.         {
  554.             if (closed == 2 && cntr == numvert) /* last vert is a repeat */
  555.             {
  556.                 closed = TRUE;
  557.                 continue;
  558.             }
  559.             eb = assoc_rb(eb, 10);
  560.             trans_euwpt(eb->resval.rpoint, 1, TRUE);
  561.             ed[cntr].x = p[0] = eb->resval.rpoint[X];
  562.             ed[cntr].y = p[1] = eb->resval.rpoint[Y];
  563.             if (frst)
  564.             {
  565.                 frst = FALSE;
  566.                 lmn[X] = lmx[X] = p[X]; 
  567.                 lmn[Y] = lmx[Y] = p[Y]; 
  568.             }
  569.             else
  570.             {
  571.                 if (p[X] < lmn[X]) 
  572.                         lmn[X] = p[X];
  573.                 if (p[X] > lmx[X])
  574.                         lmx[X] = p[X];
  575.                 if (p[Y] < lmn[Y]) 
  576.                         lmn[Y] = p[Y];
  577.                 if (p[Y] > lmx[Y]) 
  578.                         lmx[Y] = p[Y];
  579.             }
  580.             eb = assoc_rb(eb, 42);
  581.             ed[cntr].bg = eb->resval.rreal; 
  582.             cntr++;
  583.             ads_relrb(ebuf);
  584.             
  585.         }
  586.         else
  587.         {
  588.             ads_relrb(ebuf);
  589.             break;
  590.             }    
  591.     } 
  592.     /* let us zoom in on the entity and position at center */
  593.     ads_command(RTSTR, /*MSG21*/"_.zoom", RTSTR, /*MSG22*/"_w", RT3DPOINT, lmn,
  594.     RT3DPOINT, lmx, NULL);
  595.     ads_command(RTSTR, /*MSG23*/"_.zoom", RTSTR, /*MSG24*/"0.3x", NULL);
  596.  
  597.     /* get the limits and store */
  598.       if (ads_getvar(/*MSG0*/"LIMMIN", &lb1) < 0) 
  599.         off_err();
  600.       if (ads_getvar(/*MSG0*/"LIMMAX", &lb2) < 0)
  601.         off_err();
  602.  
  603.     /* get the view limits and set as new limits */
  604.       if (ads_getvar(/*MSG0*/"VSMIN", &rb) < 0) 
  605.         off_err();
  606.     ads_command (RTSTR, /*MSG25*/"_.LIMMIN", RT3DPOINT, rb.resval.rpoint, NULL);
  607.  
  608.       if (ads_getvar(/*MSG0*/"VSMAX", &rb) < 0) 
  609.         off_err();
  610.     ads_command (RTSTR, /*MSG26*/"_.LIMMAX", RT3DPOINT, rb.resval.rpoint, NULL);
  611.  
  612.     done = e_proces(e1, ed, cntr); /* process edges */
  613.     clean_up();           /* clean up the stuff */
  614.     free(ed);           /* free the array of points */
  615.     ads_command (RTSTR, /*MSG27*/"_.REGEN", NULL);
  616.     
  617.     cb.resval.rint = cmdecho; /* put back the original value */
  618.     ads_command (RTSTR, /*MSG28*/"_.LIMMIN", RT3DPOINT, lb1.resval.rpoint, NULL);
  619.     ads_command (RTSTR, /*MSG29*/"_.LIMMAX", RT3DPOINT, lb2.resval.rpoint, NULL);
  620.     ads_command (RTSTR, /*MSG30*/"_.ZOOM", RTSTR, /*MSG31*/"_E", NULL);
  621.     ads_command (RTSTR, /*MSG32*/"_.VIEW", RTSTR, /*MSG33*/"_R", RTSTR, 
  622.     /*MSG34*/"off_set", NULL);
  623.     ads_setvar(/*MSG0*/"CMDECHO", &cb);
  624.  
  625.     return (done);
  626. }
  627.  
  628. /* transform the point from one coord system to another */
  629. trans_euwpt (pt, idx, e2u)
  630. ads_point pt;
  631. int idx; 
  632. short e2u;
  633. {
  634.     ads_point result;
  635.     struct resbuf fromrb, torb;
  636.  
  637.     if (e2u) /* ECS to U/WCS */
  638.     {
  639.         fromrb.restype = RT3DPOINT;
  640.         Cpoint (fromrb.resval.rpoint, vec);
  641.         torb.restype = RTSHORT;
  642.         torb.resval.rint = idx; /* U/WCS */
  643.     }    
  644.     else /* U/WCS to ECS */
  645.     {
  646.         fromrb.restype = RTSHORT;
  647.         fromrb.resval.rint = (short)idx; /* U/WCS */
  648.         torb.restype = RT3DPOINT;
  649.         Cpoint (torb.resval.rpoint, vec);
  650.     }
  651.     if ((ads_trans (pt, &fromrb, &torb, 0, result)) != RTNORM)
  652.         off_err();
  653.     Cpoint (pt, result);
  654. }
  655.  
  656. /*  
  657.  *    Machine solid along the offset distance
  658.  */
  659.  
  660. void mac_sol()
  661. {
  662.     ads_name e1, e2;
  663.     ads_point pt;
  664.     char cmd[8], prompt[64];
  665.     Entsp ent, do_proc();
  666.     int result, cmdecho;
  667.     ads_real toff;
  668.     struct resbuf  cb;
  669.     
  670.  
  671.     if (ap_init() != AP_NORMAL)
  672.         return;
  673.     is_tool = 1;
  674.     sprintf (prompt, /*MSG35*/"Enter  the diameter of tool <%f>:", off_dist);
  675.     ads_initget (2+4, NULL); /* allow only positive values */
  676.     if (ads_getdist (NULL, prompt, &off_dist) == RTCAN)
  677.         return;
  678.     /* We are always shrinking */
  679.     is_exp = -1;
  680.  
  681.     /*
  682.      * Suppress AutoCAD command echo 
  683.     */
  684.  
  685.     ads_getvar(/*MSG0*/"CMDECHO", &cb);
  686.     cmdecho = cb.resval.rint;
  687.     cb.resval.rint = 0; /* turn the commands off */
  688.     ads_setvar(/*MSG0*/"CMDECHO", &cb);
  689.  
  690.     ads_command(RTSTR, /*MSG36*/"_.CIRCLE", RTSTR, "0, 0", RTREAL, off_dist/2.0, NULL);
  691.  
  692.     /*
  693.      * Resume AutoCAD command echo 
  694.     */
  695.  
  696.     cb.resval.rint = cmdecho;
  697.     ads_setvar(/*MSG0*/"CMDECHO", &cb);
  698.  
  699.     ads_entlast(tool_name);
  700.     tool_buf = ads_entget(tool_name);
  701.     ads_entsel(/*MSG37*/"Select closed polyline of lines (only) to machine:", e1, pt);
  702.     ent = do_proc(e1);
  703.     if (!ent)
  704.         return;
  705.     toff = off_dist;
  706.     is_tool = 2;
  707.     
  708.     sprintf(prompt, /*MSG38*/"\nContinue machining <Yes>/No: ");
  709.     /* create the offsets till we are done */
  710.     do_end(ent, toff);
  711.     off_dist = toff;
  712.     ads_relrb(tool_buf);
  713.     return;
  714. }
  715.   
  716. /* recursive routine to machine till end */
  717.  
  718. do_end(ent, toff)
  719. Entsp ent;
  720. ads_real toff;
  721. {
  722.     Entsp tmp, t2, do_proc();
  723.  
  724.     for (tmp = ent; tmp != (Entsp)NULL; tmp = tmp->nxt)
  725.     {
  726.         ent = do_proc(tmp->ename);
  727.         if (!ent)
  728.         {
  729.             is_tool = 2;
  730.             off_dist = toff;
  731.             if (!tmp->nxt)
  732.                 break;
  733.         }
  734.         else
  735.             do_end(ent, toff);
  736.     }
  737.     dump_ent(ent);
  738. }
  739.  
  740. /* free up ent */
  741.  
  742. dump_ent(ent)
  743. Entsp ent;
  744. {
  745.     Entsp tmp, t2;
  746.  
  747.     tmp = ent;           /* Free */
  748.     while (tmp != NULL)
  749.     {
  750.         t2 = tmp->nxt;
  751.         free (tmp);
  752.         tmp = t2;
  753.     }
  754. }
  755.  
  756. /*  main offsetting control routine */
  757.  
  758. Entsp
  759. e_proces(enm, edata, n)
  760. ads_name enm;
  761. Ppts edata[];
  762. short n;
  763. {
  764.     char *yy;
  765.     static char *fname = /*MSG39*/"e_process";
  766.     Entsp obj2ply();
  767.     short frmary(), treeprint();
  768.  
  769.     totpts = n;
  770.     n = n - 1;
  771.     if (frmary(edata, (long)n))
  772.         return (Entsp)NULL; /* done */
  773.     root = (Tnptr)NULL;
  774.     if (vi)
  775.     {
  776.         inidata();        /* initialization */
  777.         traverse();        /* traverse and process stored data */
  778.         if (treeprint(root, (int)-1)) /* prepare a file */
  779.             return (Entsp)NULL; /* done */
  780.         glob = root->id;
  781.     }
  782.     return (obj2ply(enm, glob, TRUE));
  783. }
  784.  
  785. /* clean up and free the data structures */
  786.  
  787. clean_up()
  788. {
  789.     Stptr stmp,stmp1;
  790.     
  791.     treedump(root);
  792.     stmp = sb;
  793.     while(stmp)
  794.     {
  795.         stmp1 = stmp->nxt;
  796.         free(stmp);
  797.         stmp = stmp1;
  798.     }
  799. }
  800.  
  801. treedump(pt)
  802. Tnptr pt;
  803. {
  804.     Vptr tmp1,tmp;
  805.     
  806.     if(pt)
  807.     {
  808.         if(pt->rht)
  809.             treedump(pt->rht);
  810.         if(pt->lft)
  811.             treedump(pt->lft);
  812.         tmp = pt->vtx;
  813.         while(tmp)
  814.         {
  815.             tmp1 = tmp;
  816.             tmp = tmp->nxt;
  817.             free(tmp1);
  818.             tmp1 = NULL;
  819.         }
  820.         free(pt);
  821.         pt = NULL;
  822.     }
  823. }
  824.  
  825. /* routine to determine direction clw or cclw and get the left bottom point */
  826.  
  827. static void
  828. detdir(xx, num, trk)
  829. Ppts xx[];
  830. long num, *trk;
  831. {
  832. #ifdef __WATCOMC__
  833.     double minx, miny, leastx, leasty, maxx, maxy;
  834. #else
  835.     double minx, miny, leastx, leasty, maxx, maxy, cos(), sin(), sqrt();
  836. #endif /* WATCOMC */
  837.     double x, y, a1, b1, a2, b2, eps, x1, y1, x2, y2, val, zero, smalleps;
  838.     float maxdim;
  839.     long prev, nxt, i;
  840.     short arc;
  841.     
  842.     x = xx[0].x;
  843.     y = xx[0].y;
  844.     minx = x;
  845.     miny = y;
  846.     maxx = leastx = x;
  847.     maxy = leasty = y;
  848.     *trk = 0;
  849.     dirn = -1;
  850.     zero = 0.0;
  851.     eps = nueps;
  852.  
  853.     for(i = 1; i <= num; i++)
  854.     {
  855.         x = xx[i].x;
  856.         y = xx[i].y;
  857.         if(x < minx && !requal(minx, x, TRUNC_EPS))
  858.         {
  859.             minx = x;
  860.             miny = y;
  861.             *trk = i;
  862.         }
  863.         else 
  864.         {
  865.             if (requal(minx, x, TRUNC_EPS))
  866.             {
  867.                 if(y < miny)
  868.                 {
  869.                     miny = y;
  870.                     *trk = i;
  871.                 }
  872.             }
  873.         }
  874.         if(x < leastx)
  875.             leastx = x;
  876.         if(y <leasty)
  877.             leasty = y;
  878.         if(x > maxx)
  879.             maxx = x;
  880.         if(y > maxy)
  881.             maxy = y;
  882.     }
  883.     if(*trk == num)
  884.         nxt =  0;
  885.     else
  886.         nxt = *trk + 1;
  887.     if(*trk == 0)
  888.         prev = num;
  889.     else 
  890.         prev = *trk - 1;
  891.     x1 = xx[prev].x;
  892.     y1 = xx[prev].y;
  893.     x2 = xx[nxt].x;
  894.     y2 = xx[nxt].y;
  895.     a1 = x2 - minx;
  896.     b1 = y2 - miny;
  897.     a2 = minx - x1;
  898.     b2 = miny - y1;
  899.     val = a1 * b2 - b1 * a2;
  900.     smalleps = eps * sqrt(a1 * a1 + b1 * b1);
  901.     if(c_reqa(&val, &zero, &smalleps))
  902.         ;
  903.     else
  904.         if(val > 0.0)
  905.             dirn = 1; /* clw */
  906. }
  907.  
  908. /* set up the data structures */
  909.  
  910. short
  911. frmary(xx, num)
  912. Ppts xx[];
  913. long num;
  914. {
  915.     long i;
  916.     Vptr vb, vutmp, tb, tmp;
  917.     long trk;
  918.     double  x, y;
  919.     
  920.     detdir(xx, num, &trk);
  921.     tb = NULL;
  922.     vb  = NULL;
  923.     root = NULL;
  924.     sb = NULL;
  925.     i = trk;
  926.     for(i = trk; i <= num; i++)
  927.     {
  928.         x = xx[i].x;
  929.         y = xx[i].y;
  930.         if ((vi = (Vptr)malloc(sizeof(Vertex))) == (Vptr)NULL)
  931.         {
  932.             off_err();
  933.             return TRUE;
  934.         }
  935.         vi->x = x;
  936.         vi->y = y;
  937.         vi->flag = (short)i;
  938.         vi->bg = xx[i].bg;
  939.         vi -> nxt = vb;
  940.         vb = vi;
  941.     }
  942.     if(trk != 0)
  943.     {
  944.         for(i = 0; i <= trk - 1; i++)
  945.         {
  946.             x = xx[i].x;
  947.             y = xx[i].y;
  948.             if ((vi = (Vptr)malloc(sizeof(Vertex))) == (Vptr)NULL)
  949.             {
  950.                 off_err();
  951.                 return TRUE;
  952.             }
  953.             vi->x = x;
  954.             vi->y = y;
  955.             vi->flag = (short)i;
  956.             vi -> nxt = vb;
  957.             vb = vi;
  958.         }  /* if */
  959.     } /* for */
  960.     x = xx[trk].x;
  961.     y = xx[trk].y;
  962.     if ((vi = (Vptr)malloc(sizeof(Vertex))) == (Vptr)NULL)
  963.     {
  964.         off_err();
  965.         return TRUE;
  966.     }
  967.     vi->x = x;
  968.     vi->y = y;
  969.     vi->flag = (short)trk;
  970.     vi->nxt = vb;
  971.     vb = vi;
  972.     /* this is the time to eliminate any introduced co-linear pts. 
  973.         and avoid redundancies */
  974.     if(vi->nxt->nxt->nxt == NULL)
  975.         vi = NULL;
  976.     else
  977.     {
  978.         vutmp = vi;
  979.         rmcolin(&vutmp);
  980.         vi = vutmp;
  981.         vb = vi;
  982.         if(dirn == 1) /* user draws clw. but pts stored cclw. rev the stuff */
  983.         {
  984.             tmp = vb;
  985.             while(tmp)
  986.             {
  987.                 vi = (Vptr)malloc(sizeof(Vertex));
  988.                 if (vi == (Vptr)NULL)
  989.                 {
  990.                     off_err();
  991.                     return TRUE;
  992.                 }
  993.                 vi->x = tmp->x;
  994.                 vi->y = tmp->y;
  995.                 vi->flag = tmp->flag;
  996.                 vi->nxt = tb;
  997.                 tb = vi;
  998.                 tmp = tmp->nxt;
  999.             }
  1000.             vdump(vb);
  1001.         }   /* if dirn */
  1002.         tmp = vi;
  1003.         /*
  1004.             while(tmp)
  1005.             {
  1006.                 printf("vi x y %f %f\n", tmp->x, tmp->y); 
  1007.                 tmp = tmp->nxt;
  1008.             } 
  1009.         */
  1010.     }
  1011.     return FALSE;
  1012. }
  1013.  
  1014. /* remove colinear points */
  1015.  
  1016. rmcolin(curpt)
  1017. Vptr *curpt;
  1018. {
  1019.     Vptr sto, ntmp, tmp;
  1020.     short cur_code, loop, mcode;
  1021.     double  eps, x, y, cur_m, cur_c, m, c, x_dif, y_dif;
  1022.     
  1023.     eps = nueps;
  1024.     tmp = *curpt;
  1025.     if(!tmp)
  1026.         return;
  1027.     if(tmp->nxt)
  1028.     {
  1029.         y_dif = tmp->nxt->y - tmp->y;
  1030.         x_dif = tmp->nxt->x - tmp->x;
  1031.         if(f_abs(x_dif) < ueps1)
  1032.             cur_code = 1;
  1033.         else
  1034.         {
  1035.             cur_code = 0;
  1036.             cur_m = y_dif / x_dif;
  1037.             cur_c = tmp->y - cur_m * tmp->x;
  1038.         }
  1039.     }
  1040.     while(tmp->nxt && tmp->nxt->nxt)
  1041.     {
  1042.         do
  1043.         {
  1044.             loop = 0;
  1045.             y_dif = tmp->nxt->nxt->y - tmp->nxt->y;
  1046.             x_dif = tmp->nxt->nxt->x - tmp->nxt->x;
  1047.             if(f_abs(x_dif) < ueps1)
  1048.                 mcode = 1;
  1049.             else 
  1050.             {
  1051.                 mcode = 0;
  1052.                 m = y_dif / x_dif;
  1053.                 c = tmp->nxt->y - m * tmp->nxt->x;
  1054.             }
  1055.             if(cur_code == 1 && mcode == 1)
  1056.             {
  1057.                 sto = tmp->nxt;
  1058.                 tmp->nxt = sto->nxt;
  1059.                 free(sto);
  1060.                 sto = NULL;
  1061.                 loop = 1;
  1062.             }
  1063.             else 
  1064.             {
  1065.                 if(cur_code == 0 && mcode == 0)
  1066.                 {
  1067.                     if(c_reqa(&cur_c, &c, &eps) && c_reqa(&cur_m, &m, &eps))
  1068.                     {
  1069.                         sto = tmp->nxt;
  1070.                         tmp->nxt = sto->nxt;
  1071.                         free(sto);
  1072.                         sto = NULL;
  1073.                         loop = 1;
  1074.                     }
  1075.                 }
  1076.             }
  1077.         } 
  1078.         while(loop == 1 && tmp->nxt->nxt);
  1079.         cur_code = mcode;
  1080.         cur_m = m;
  1081.         cur_c = c;
  1082.         tmp = tmp->nxt;
  1083.     }  /* while ends */
  1084.     /* we need to perform one last step to homogenize the data 
  1085.         namely check the last two points with the last but one point */
  1086.     tmp = *curpt;
  1087.     if(tmp->nxt)
  1088.     {
  1089.         while(tmp->nxt->nxt)
  1090.             tmp = tmp->nxt;
  1091.         y_dif = tmp->nxt->y - tmp->y;
  1092.         x_dif = tmp->nxt->x - tmp->x;
  1093.         if(f_abs(x_dif) < ueps1)
  1094.             cur_code = 1;
  1095.         else
  1096.         {
  1097.             cur_code = 0;
  1098.             cur_m = y_dif / x_dif;
  1099.             cur_c = tmp->y - cur_m * tmp->x;
  1100.         }
  1101.         ntmp = *curpt;
  1102.         y_dif = ntmp->nxt->y - ntmp->y;
  1103.         x_dif = ntmp->nxt->x - ntmp->x;
  1104.         if(f_abs(x_dif) < ueps1)
  1105.             mcode = 1;
  1106.         else 
  1107.         {
  1108.             mcode = 0;
  1109.             m = y_dif / x_dif;
  1110.             c = ntmp->y - m * ntmp->x;
  1111.         }
  1112.         if(cur_code == 1 && mcode == 1)
  1113.         {
  1114.             sto = ntmp->nxt;
  1115.             free(*curpt);
  1116.             *curpt = sto;
  1117.             tmp->nxt->x = sto->x;
  1118.             tmp->nxt->y = sto->y;
  1119.         }
  1120.         else 
  1121.         {
  1122.             if(cur_code == 0 && mcode == 0)
  1123.             {
  1124.                 if(c_reqa(&cur_c, &c, &eps) && c_reqa(&cur_m, &m, &eps))
  1125.                 {
  1126.                     sto = ntmp->nxt;
  1127.                     free(*curpt);
  1128.                     *curpt = sto;
  1129.                     tmp->nxt->x = sto->x;
  1130.                     tmp->nxt->y = sto->y;
  1131.                 }
  1132.             }
  1133.         }
  1134.     } 
  1135. }
  1136.  
  1137. /* free the vertices (list) */
  1138.  
  1139. vdump(vb)
  1140. Vptr vb;
  1141. {
  1142.     if(vb)
  1143.     {
  1144.         vdump(vb->nxt);
  1145.         free(vb);
  1146.         vb = NULL;
  1147.     }
  1148. }
  1149.  
  1150.  
  1151. /* initialize the data */
  1152.  
  1153. inidata()
  1154. {
  1155.     i2 = 1;
  1156.     if ((root = treealloc(0l)) == NULL)
  1157.         return;
  1158.     if ((sb = (Stptr) malloc(sizeof (Store))) == (Stptr)NULL)
  1159.     {
  1160.         off_err();
  1161.         return;
  1162.     }
  1163.     sb -> ptr = root;
  1164.     sb -> pid = root;
  1165.     sb -> nxt = NULL;
  1166.     root -> vtx = vi;
  1167.     scur = sb;
  1168. }
  1169.  
  1170.  
  1171. /* 
  1172.  * u - given pt: v - nxt pt:w - index thru remaining pts. 
  1173.  * algorithm -> if cross product of vec[u, v] and vec [u, w] pts. out 
  1174.  * v forms a dip 
  1175.  */
  1176.  
  1177. Vptr lmost(u)    /* function which dets. the next leftmost value */
  1178. Vptr u;
  1179. {
  1180.     double  a1, a2, b1, b2;    /* i,j components of the vectors */
  1181.     Vptr v, w;
  1182.  
  1183.     if(u -> nxt -> nxt == 0)
  1184.         v = u -> nxt;
  1185.     else
  1186.     {
  1187.         v = u -> nxt;
  1188.         a1 = v -> x - u -> x;
  1189.         a2 = v -> y - u -> y;
  1190.         w = v -> nxt;
  1191.         do
  1192.         {
  1193.             b1 = w -> x - u -> x;
  1194.             b2 = w -> y - u -> y;
  1195.             if(a1 * b2 - a2 * b1 > 0.0)
  1196.             {
  1197.                 v = w;
  1198.                 a1 = b1;
  1199.                 a2 = b2;
  1200.             }
  1201.             w = w -> nxt;
  1202.         } 
  1203.         while(w);
  1204.     }
  1205.     return(v);
  1206. }
  1207.  
  1208. /* main recursive function which runs thru stored data */
  1209.  
  1210. traverse()
  1211. {
  1212.     Stptr r;
  1213.     
  1214.     do
  1215.     {
  1216.         r = sb;
  1217.         process(r);
  1218.         sb = sb -> nxt;
  1219.         free(r);
  1220.         r = NULL;
  1221.     } 
  1222.     while(sb);
  1223. }
  1224.  
  1225. Tnptr maketree(u, v, ptr, cod)            /* makes tree */
  1226. long cod;                    /* code for un or dif */
  1227. Tnptr ptr;                    /* present tree pointer */
  1228. Vptr u, v;                    /* ptrs to rel. vtx info. */
  1229. {
  1230.     Tnptr q, r;
  1231.     Stptr s;
  1232.     Vptr ncopy();
  1233.  
  1234.     if ((q = treealloc(cod)) == (Tnptr)NULL)
  1235.         return (Tnptr)NULL;
  1236.     if ((r = treealloc(cod)) == (Tnptr)NULL)
  1237.         return (Tnptr)NULL;
  1238.     if(scur -> ptr == root)
  1239.     {
  1240.         q -> lft = root;
  1241.         root = q;
  1242.         root -> idx = -1L; /* Sub */
  1243.         q -> lft -> lft = NULL;
  1244.         q -> lft -> rht = NULL;
  1245.         root->vtx = NULL;
  1246.     }
  1247.     else
  1248.     {
  1249.         if(cod == 1)
  1250.         {
  1251.             q -> lft = r;
  1252.             ptr -> rht = q;
  1253.             r -> vtx = ncopy(u, v);
  1254.             r -> op = 0L; /* prim */
  1255.             if ((s = (Stptr) malloc(sizeof (Store))) == (Stptr)NULL)
  1256.             {
  1257.                 off_err();
  1258.                 return (Tnptr)NULL;
  1259.             }
  1260.             s -> ptr = q;
  1261.             s -> pid = r;
  1262.             s -> nxt = NULL;
  1263.             scur -> nxt = s;
  1264.             scur = scur -> nxt;
  1265.         }
  1266.         else
  1267.         {
  1268.             q -> lft = ptr -> lft;
  1269.             ptr -> lft = q;
  1270.         }
  1271.     }
  1272.     return(q);
  1273. }
  1274.  
  1275. static Tnptr                 /* allocate the tree node */
  1276. treealloc(cod)
  1277. long cod;
  1278. {
  1279.     Tnptr t;
  1280.     static char *fname = /*MSG40*/"treealloc";
  1281.  
  1282.     if((t = (Tnptr)malloc(sizeof(Trenod))) == NULL)
  1283.     {
  1284.         off_err();
  1285.         return(NULL);
  1286.     }
  1287.     t -> vtx = NULL;
  1288.     t -> lft = NULL;
  1289.     t -> rht = NULL;
  1290.     t -> op = cod;
  1291.     t -> idx = -1l;
  1292.     t -> id = 0L;
  1293.     return(t);
  1294. }
  1295.  
  1296. process(cur) /* process current storage data ptr for convex hull */
  1297. Stptr cur;
  1298. {
  1299.     Tnptr r, t, maketree();
  1300.     Vptr u, v, w, p, lmost();    /* vertex data ptrs */
  1301.     double fact = 1.5;
  1302.     double pt1[2], pt2[2];
  1303.     short chk_mor(), l;
  1304.  
  1305.     if ((t = maketree(0L, 0L, cur -> ptr, -1L)) == (Tnptr)NULL)
  1306.         return;
  1307.     u = cur -> pid -> vtx;
  1308.     if(u)
  1309.     {
  1310.         while(u -> nxt)
  1311.         {
  1312.             v = lmost(u);
  1313.             if(u -> nxt != v)    /* concavity found */
  1314.             {
  1315.                 r = maketree(u, v, t, 1L);
  1316.                 /* fix u and v points */
  1317.                 w = v->nxt;
  1318.                 if (!w)
  1319.                     w = cur->pid->vtx->nxt;
  1320.                 p = w;
  1321.                 get_opnt(w->x, w->y, v->x, v->y, pt2, -fact);
  1322.                 if (u == cur->pid->vtx)
  1323.                     for (w = u; w->nxt->nxt != (Vptr)NULL; w = w->nxt);
  1324.                 else
  1325.                     for (w = cur->pid->vtx; w->nxt != u; w = w->nxt);
  1326.                 get_opnt(w->x, w->y, u->x, u->y, pt1, -fact);
  1327.                 l = chk_mor (p, v, w, u, pt1, pt2, fact);
  1328.                 v->x = pt2[0]; v->y = pt2[1];
  1329.                 if (!(v->nxt)) /* update 1st pt also */
  1330.                 {
  1331.                     cur->pid->vtx->x = v->x;
  1332.                     cur->pid->vtx->y = v->y;
  1333.                 }
  1334.                 u->x = pt1[0]; u->y = pt1[1];
  1335.                 if (u == cur->pid->vtx) /* update last pt also*/
  1336.                 {
  1337.                     w->nxt->x = u->x;
  1338.                     w->nxt->y = u->y;
  1339.                     if (l)
  1340.                     {
  1341.                         cur->pid->vtx = u->nxt;
  1342.                         free (u);
  1343.                         p = w->nxt;
  1344.                         w->nxt = (Vptr)NULL;
  1345.                         free (p);
  1346.                     }
  1347.                 }
  1348.                 else if (l)
  1349.                 {
  1350.                     w->nxt = v;
  1351.                     free (u);
  1352.                 }
  1353.                 if (r == (Tnptr)NULL)
  1354.                     return;
  1355.                 t = r;
  1356.             }
  1357.             u = v;
  1358.         } 
  1359.     }
  1360. }
  1361.  
  1362. /*
  1363.  * Find the intersection point. If this is at a smaller distance than
  1364.  * p1 or p2. Equate p1 and p2 to this point.
  1365.  */
  1366.  
  1367. short
  1368. chk_mor(p, v, w, u, pt1, pt2, fact)
  1369. Vptr p, v, w, u;
  1370. ads_real fact, pt1[2], pt2[2];
  1371. {
  1372.     Point p1, p2; 
  1373.     Line l1, l2;
  1374. #ifdef __WATCOMC__
  1375.     ads_real dist;
  1376. #else
  1377.     ads_real dist, sqrt();
  1378. #endif /* WATCOMC */
  1379.     short st_line();
  1380.     extern ads_real off_dist;
  1381.     
  1382.     p1.x = p->x; p1.y = p->y;
  1383.     p2.x = v->x; p2.y = v->y;
  1384.     if (!st_line(p1, p2, &l1))
  1385.         return 0;
  1386.     p1.x = w->x; p1.y = w->y;
  1387.     p2.x = u->x; p2.y = u->y;
  1388.     if (!st_line(p1, p2, &l2))
  1389.         return 0;
  1390.  
  1391.     if(requal(l1.a * l2.b, l1.b * l2.a, EXT_EPS))
  1392.         return 0; /* parallel lines */ 
  1393.     /* intersection point now */
  1394.         p1.x = (l2.c * l1.b - l1.c * l2.b) / (l1.a * l2.b - l2.a * l1.b) ;      
  1395.         p1.y = (l1.c * l2.a - l2.c * l1.a) / (l1.a * l2.b - l2.a * l1.b) ;   
  1396.     fact = off_dist*f_abs(fact);
  1397.     p2.x = p1.x - v->x; p2.y = p1.y - v->y;
  1398.     dist = sqrt((p2.x*p2.x) + (p2.y*p2.y));
  1399.     if (dist < fact)
  1400.     {
  1401.         pt1[0] = p1.x; pt1[1] = p1.y; 
  1402.         pt2[0] = p1.x; pt2[1] = p1.y; 
  1403.         return 1;
  1404.     } 
  1405.     p2.x = p1.x - u->x; p2.y = p1.y - u->y;
  1406.     dist = sqrt((p2.x*p2.x) + (p2.y*p2.y));
  1407.     if (dist < fact)
  1408.     {
  1409.         pt1[0] = p1.x; pt1[1] = p1.y; 
  1410.         pt2[0] = p1.x; pt2[1] = p1.y; 
  1411.         return 1;
  1412.     } 
  1413.     return 0;
  1414. }
  1415.  
  1416. Vptr ncopy(u, v)    /* copies the list from u, v in reverse order */
  1417. Vptr u, v;
  1418. {
  1419.     Vptr temp, t, tb;
  1420.     double pt1[2], pt2[2];
  1421.     double fact = 100.0; /* *FHACK* */
  1422.     
  1423.     /* 
  1424.          * Instead of this hard coded number it is probably better to tie
  1425.      * this to the largest dimension of the box. You have to tweak this
  1426.          * number for drawing with big dimensions.
  1427.      */
  1428.     tb = NULL;
  1429.     t = u;
  1430.     get_opnt(u->nxt->x, u->nxt->y, u->x, u->y, pt1, fact);
  1431.     do
  1432.     {
  1433.         if ((temp = (Vptr) malloc(sizeof (Vertex))) == (Vptr)NULL)
  1434.         {
  1435.             off_err();
  1436.             return (Vptr)NULL;
  1437.         }
  1438.         if (t != u)
  1439.         {
  1440.             temp -> x = t -> x;
  1441.             temp -> y = t -> y;
  1442.         }
  1443.         else
  1444.         {
  1445.             temp -> x = pt1[0];
  1446.             temp->  y = pt1[1]; 
  1447.         }
  1448.         temp -> nxt = tb;
  1449.         tb = temp;
  1450.         t = t -> nxt;
  1451.     } 
  1452.     while(t->nxt != v);
  1453.     if ((temp = (Vptr) malloc(sizeof (Vertex))) == (Vptr)NULL)
  1454.     {
  1455.         off_err();
  1456.         return (Vptr)NULL;
  1457.     }
  1458.     temp -> x = t -> x;
  1459.     temp -> y = t -> y;
  1460.     temp -> nxt = tb;
  1461.     tb = temp;
  1462.     get_opnt(t->x, t->y, v->x, v->y, pt2, fact);
  1463.     if ((temp = (Vptr) malloc(sizeof (Vertex))) == (Vptr)NULL)
  1464.     {
  1465.         off_err();
  1466.         return (Vptr)NULL;
  1467.     }
  1468.     temp -> x = pt2[0];
  1469.     temp -> y = pt2[1];
  1470.     temp -> nxt = tb;
  1471.     tb = temp;
  1472.     if ((t = (Vptr) malloc(sizeof (Vertex))) == (Vptr)NULL)
  1473.     {
  1474.         off_err();
  1475.         return (Vptr)NULL;
  1476.     }
  1477.     t -> x = pt1[0];
  1478.     t -> y = pt1[1];
  1479.     t -> nxt = tb;
  1480.     tb = t;
  1481.     /* all the values are copied now : modify original list */
  1482.     temp = u -> nxt;
  1483.     u -> nxt = v;
  1484.     ndump(temp, v);
  1485.     return(t);
  1486. }
  1487.  
  1488. /* offset the lines by the given factor and compute the intersection pt. */
  1489.  
  1490. get_opnt(x1, y1, x2, y2, pt, fact)
  1491. double x1, y1, x2, y2;
  1492. double pt[2];
  1493. double fact;
  1494. {
  1495.     extern ads_real off_dist;
  1496. #ifdef __WATCOMC__
  1497.     double u[2], v[2], dist;
  1498. #else
  1499.     double u[2], v[2], dist, sqrt();
  1500. #endif /* WATCOMC */
  1501.     int i1 = 0, i2 = 1;
  1502.  
  1503.     fact *= off_dist;
  1504.     v[0] = x2 - x1;
  1505.     v[1] = y2 - y1;
  1506.     dist =  sqrt(v[0] * v[0] + v[1] * v[1]);
  1507.     v[0] /= dist; v[1] /= dist;
  1508.     if (fact > 0)
  1509.     {
  1510.         ;
  1511.     }
  1512.     else
  1513.         fact = f_abs(fact);
  1514.     pt[0] = x2 +  (v[0]*fact);
  1515.     pt[1] = y2 +  (v[1]*fact);
  1516. }
  1517.  
  1518. ndump(a, b)            /* free storage from a to b */
  1519. Vptr a, b;
  1520. {
  1521.     Vptr temp;
  1522.  
  1523.     while(a != b)
  1524.     {
  1525.         temp = a -> nxt;
  1526.         free(a);
  1527.         a = temp;
  1528.     }
  1529. }
  1530.  
  1531. short
  1532. treeprint(pt, val) /* go through the tree and prepare a CSG file */
  1533. Tnptr pt;
  1534. int val;
  1535. {
  1536.     short outprim();
  1537.  
  1538.     if(pt)
  1539.     {
  1540.         if(pt -> op != 0)
  1541.         {
  1542.             val *= pt->op;
  1543.             if(pt -> rht)
  1544.             {
  1545.                 if (treeprint(pt -> rht, val))
  1546.                     return TRUE;
  1547.                 treeprint(pt -> lft, val);
  1548.                 if(pt->op == -1) /* diff */
  1549.                 {
  1550.                     if(pt->lft->id && pt->rht->id)
  1551.                         pt->id = mknbl((ap_Objid)pt->lft->id, (ap_Objid)pt->rht->id, OP_DIF);
  1552.                     else
  1553.                     {
  1554.                         pt->id = pt->lft->id;
  1555.                         if(!pt->id)
  1556.                             pt->id = pt->rht->id;
  1557.                     }
  1558.                 }
  1559.                 else /* Union */
  1560.                 {
  1561.                     if(pt->lft->id && pt->rht->id)
  1562.                         pt->id = mknbl((ap_Objid)pt->lft->id, (ap_Objid)pt->rht->id, OP_UN);
  1563.                     else
  1564.                     {
  1565.                         pt->id = pt->lft->id;
  1566.                         if(!pt->id)
  1567.                             pt->id = pt->rht->id;
  1568.                     }
  1569.                 }
  1570.             }
  1571.             else
  1572.             {
  1573.                 treeprint(pt -> lft, val);
  1574.                 pt->id = pt->lft->id;
  1575.             }
  1576.         }
  1577.         else
  1578.             if (outprim(pt, val))
  1579.                 return TRUE;
  1580.     }
  1581.     return FALSE;
  1582. }
  1583.  
  1584. short
  1585. outprim(pt, val) /* make edge polys and store ids -> no arcs */
  1586. Tnptr pt;
  1587. int val;  /* offset val */
  1588. {
  1589.  
  1590.     ads_name ename;
  1591.     long do_prim();
  1592.     Vptr u;
  1593.  
  1594.     u = pt -> vtx;
  1595.     rmcolin(&u); /* remove colinear points */
  1596.     if(u && u->nxt && u->nxt->nxt)
  1597.         pt->id = do_prim(u, val);
  1598.     else
  1599.         off_err();
  1600.     if (!pt->id)
  1601.         return TRUE;
  1602.     else
  1603.         return FALSE;
  1604. }
  1605.  
  1606.  
  1607. /* ==================== BUILD POLY ===================  */
  1608.  
  1609. /* build polygon from vertices data structs */
  1610.  
  1611. build_poly(u)
  1612. Vptr u;
  1613. {
  1614.     Vptr tmp;
  1615.      int cnt, i, poly_build(), seq_end(), status;
  1616.         struct resbuf *entlist, rb;
  1617.         ads_point pnt;
  1618.     ads_real lmin[2], lmax[2];
  1619.                 
  1620.     cen[0] = cen[1] = 0.0, cnt = 0;
  1621.  
  1622.       if (ads_getvar(/*MSG0*/"LIMMIN", &rb) < 0) 
  1623.         off_err();
  1624.     lmin[0] = rb.resval.rpoint[0]; lmin[1] = rb.resval.rpoint[1];
  1625.       if (ads_getvar(/*MSG0*/"LIMMAX", &rb) < 0) 
  1626.         off_err();
  1627.     lmax[0] = rb.resval.rpoint[0]; lmax[1] = rb.resval.rpoint[1];
  1628.  
  1629.         /* In this case we know how points are */
  1630.     if (!poly_build())
  1631.         return;
  1632.     fsp[0] = u->x; fsp[1] = u->y;
  1633.     snd[0] = u->nxt->x; snd[1] = u->nxt->y;
  1634.     plim[0] = 0.0; plim[1] = 0.0;
  1635.         for (tmp = u; tmp->nxt != (Vptr)NULL; tmp = tmp->nxt)
  1636.         {
  1637.         cnt++;
  1638.                 pnt[X] = tmp->x; pnt[Y] = tmp->y;
  1639.         pnt[Z] = 0.0;
  1640.         /*
  1641.          *  Since the offset command expects a point on the object
  1642.              *  well within limits for its selection. Make sure that we
  1643.          *  get such a point and store.
  1644.          */
  1645.         /*
  1646.          * Plim is really not needed anymore as the entity name
  1647.          * can be passed before any point for the offset command
  1648.          */
  1649.         if (pnt[0] > lmin[0] && pnt[1] > lmin[1] && pnt[0] < lmax[0]
  1650.             && pnt[1] < lmax[1])
  1651.         {
  1652.             plim[0] = pnt[0];
  1653.             plim[1] = pnt[1];
  1654.         }
  1655.         cen[X] += pnt[X]; cen[Y] += pnt[Y];
  1656.         tmp->bg = 0.0;
  1657.                 if ((vert_build(pnt, tmp->bg, 1))!= RTNORM)
  1658.                         return;
  1659.         }
  1660.     if (!seq_end())
  1661.         return;    
  1662.     cen[X] /= cnt; cen[Y] /= cnt;
  1663. }
  1664.  
  1665. /* build polyline entity */
  1666.  
  1667. int 
  1668. poly_build()
  1669. {
  1670.         int status;
  1671.         struct resbuf *entlist;
  1672.  
  1673.         entlist = ads_buildlist(RTDXF0, /*MSG0*/"POLYLINE",  /* Type of entity */
  1674.                                 8,  name,        /* layer name */
  1675.                   210,  vec,         /* entity vector */
  1676.                                66,  1,          /* vertices follow */
  1677.                                70,  1,          /* close polyline */
  1678.                                NULL );          /* end */
  1679.         if (entlist == NULL)
  1680.                 ads_fail(/*MSG41*/"Unable to create result buffer list.");
  1681.         status = ads_entmake(entlist);
  1682.         ads_relrb(entlist);       /* Rel. ads_entmake() buffer */
  1683.         if (status != RTNORM){
  1684.                 ads_fail (/*MSG42*/"Unable to make polyline entity.");
  1685.                 return 0;
  1686.         }
  1687.         return 1;
  1688. }
  1689.  
  1690. /* build vertex entities */
  1691.  
  1692. int 
  1693. vert_build(pnt, bg, idx)
  1694. ads_point pnt;
  1695. ads_real bg;
  1696. int idx;
  1697. {
  1698.         int status;
  1699.         struct resbuf *entlist;
  1700.  
  1701.     /*
  1702.     bg = 0.0;
  1703.     */
  1704.     trans_euwpt(pnt, idx, FALSE);
  1705.         entlist = ads_buildlist(RTDXF0, /*MSG0*/"VERTEX",    /* Type of entity */
  1706.                                 8, name,         /* layer name */
  1707.                                10,  pnt,        /* point */
  1708.                                42, bg,          /* bulge factor */
  1709.                                NULL );          /* end */
  1710.  
  1711.  
  1712.         if (entlist == NULL)
  1713.                 ads_fail(/*MSG43*/"Unable to create result buffer list.");
  1714.         status = ads_entmake(entlist);
  1715.         ads_relrb(entlist);                    /* Rel. ads_entmake() buffer */
  1716.         if (status != RTNORM){
  1717.                 ads_fail (/*MSG44*/"Unable to make vertex entity.");
  1718.                 return 0;
  1719.         }
  1720.         return status;
  1721. }
  1722.  
  1723. /* build seq_end part */
  1724.  
  1725. int
  1726. seq_end()
  1727. {
  1728.         int status;
  1729.         struct resbuf *entlist;
  1730.  
  1731.         /* We want to end the list now */
  1732.         entlist = ads_buildlist(RTDXF0, /*MSG0*/"SEQEND",  /* Type of entity */
  1733.                                 8, name,         /* layer name */
  1734.                                NULL );          /* end */
  1735.                                 
  1736.  
  1737.         if (entlist == NULL)
  1738.                 ads_fail(/*MSG45*/"Unable to create result buffer list.");
  1739.         status = ads_entmake(entlist);
  1740.         ads_relrb(entlist);                    /* Rel. ads_entmake() buffer */
  1741.         if (status != RTNORM){
  1742.                 ads_fail (/*MSG46*/"Unable to make SEQEND.");
  1743.                 return 0;
  1744.         }
  1745.     return 1;
  1746. }
  1747.  
  1748. short
  1749. off_set (ename, val) /* go through the tree and off_set */
  1750. ads_name ename;
  1751. int val;
  1752. {
  1753.     int i;
  1754.     ads_real avg[2];
  1755.     short off_debug = 1;
  1756.     short chk_shrink();
  1757.     ads_name e1;
  1758.     int test;
  1759.  
  1760.     val *= is_exp; 
  1761.     /* come up with the point */
  1762.     
  1763.     if (val == -1) /* shrink */
  1764.     {
  1765.        test = ads_command (RTSTR, /*MSG47*/"_.OFFSET", RTREAL, off_dist, RTENAME, ename, RTPOINT, plim, RTPOINT, cen, RTSTR, "", NULL);
  1766.        if (test != RTNORM)
  1767.        {
  1768.         ads_printf ("Error in AutoCAD offsetting. Exiting...\n");
  1769.         exit(1);    
  1770.        }
  1771.       /* we have to check if we got a proper offset or not */
  1772.        ads_entlast (e1);
  1773.        if (!chk_shrink(ename, e1))
  1774.        {
  1775.         ads_command (RTSTR, /*MSG48*/"_.erase", RTENAME, ename, RTSTR, "", NULL);
  1776.         return FALSE; /* done */
  1777.        }
  1778.     }
  1779.     else /* expand */
  1780.     {
  1781.         avg[0] = (fsp[0]+snd[0])/2.0;
  1782.         avg[1] = (fsp[1]+snd[1])/2.0;
  1783.         cen[0] = 2*avg[0] - cen[0];
  1784.         cen[1] = 2*avg[1] - cen[1];
  1785.             test = ads_command (RTSTR, /*MSG49*/"_.offset", RTREAL, off_dist, RTPOINT, plim, RTPOINT, cen, RTSTR, "", NULL);
  1786.             if (test != RTNORM)
  1787.             {
  1788.             ads_printf ("Error in AutoCAD offsetting. Exiting...\n");
  1789.             exit(1);    
  1790.            }
  1791.     }
  1792.      if (off_debug)
  1793.     ads_command (RTSTR, /*MSG50*/"_.erase", RTENAME, ename, RTSTR, "", NULL);
  1794.     return TRUE;
  1795. }
  1796.  
  1797. /* build the convex hull object */
  1798.  
  1799. long
  1800. do_prim(u, val)
  1801. Vptr u;
  1802. int val;
  1803. {
  1804.     ads_name ename;
  1805.     ap_Objid obj;
  1806.     short off_set(), cde;
  1807.  
  1808.     build_poly(u);
  1809.     ads_entlast(ename);
  1810.     cde = off_set(ename, val); /* no proper offset */
  1811.     if (!cde)
  1812.         return 0L;
  1813.     ads_entlast(ename);
  1814.     if (ap_solidify(ename, &obj) != AP_NORMAL)
  1815.         off_err();
  1816.     ads_command (RTSTR, /*MSG51*/"_.erase", RTENAME, ename, RTSTR, "", NULL);
  1817.     return (long)obj;
  1818. }
  1819.  
  1820. /* create csg branch node with appropriate operator */
  1821.  
  1822. long
  1823. mknbl(ob1, ob2, op)
  1824. ap_Objid ob1, ob2;
  1825. short op;
  1826. {
  1827.     ap_Objid objs[3], obj;
  1828.     ads_name en1, en2;
  1829.     
  1830.     objs[0] = ob1;
  1831.     objs[1] = ob2;
  1832.     objs[2] = (ap_Objid)NULL;
  1833.     if (op == 1)
  1834.         ap_union(objs, &obj);
  1835.     else
  1836.         ap_subtract(ob1, ob2, &obj);    
  1837.         ap_post_obj(obj, AP_POSTWIRE);
  1838.     return (long)obj;
  1839. }
  1840.  
  1841. /* convert the object to poly */
  1842.  
  1843. Entsp 
  1844. obj2ply(enm, obj, flag)
  1845. ads_name enm;
  1846. ap_Objid obj;
  1847. short flag;
  1848. {
  1849.     ap_Edgelist *elist, *slist;
  1850.     ap_Objinfo info;
  1851.     ap_Featid *llist, *temp;
  1852.     int polt_build(), seq_end(), vert_build();
  1853.     ads_real bg, get_bg();
  1854.     extern int is_tool;
  1855.     ads_name e1;
  1856.     ap_Objid ob1, obs[3];
  1857.     Entsp eb = (Entsp)NULL, et, new_entsp();
  1858.     ads_real x1, y1, x2, y2, x3, y3;
  1859.  
  1860.     if (!obj || is_tool == -1)
  1861.         return NULL;
  1862.     obs[2] = (ap_Objid)NULL;
  1863.     if (ap_get_objinfo(obj, &info) < 0)
  1864.     {
  1865.         off_err();
  1866.         return NULL;
  1867.     }
  1868.     if (info.isnull)
  1869.     {
  1870.         if (!is_tool)
  1871.         {
  1872.             ads_printf
  1873.             (/*MSG52*/"Resultant offset is NULL. Try a smaller offset distance...\n");
  1874.             ads_command(RTSTR,"_.ERASE", RTSTR, "_l", RTSTR, "", NULL);/* erase null symbol */
  1875.             return (Entsp)NULL;
  1876.         }
  1877.         else
  1878.         {
  1879.             off_dist /= 2.0;
  1880.             ap_del_obj(obj);
  1881.             et = new_entsp();
  1882.             et->nxt = eb;
  1883.             eb = et;
  1884.             eb->ename[0] = enm[0]; /* send back orig ent */
  1885.             eb->ename[1] = enm[1];
  1886.             return eb; /* try with a smaller offset HACK */
  1887.         }
  1888.     } 
  1889.     if ((ap_obj2loops(obj, &llist) < 0))
  1890.     {
  1891.         off_err();
  1892.         return (Entsp)NULL;
  1893.     }
  1894.     for (temp = llist; *temp != (ap_Featid) NULL; temp++) 
  1895.     {
  1896.         if (ap_loop2edges(obj, *temp, TRUE, &elist) < 0)
  1897.         {
  1898.             off_err();
  1899.             return (Entsp)NULL;
  1900.         }
  1901.         /* HACK for Circle */
  1902.             
  1903.         if (flag && !poly_build())
  1904.             return (Entsp)NULL;    
  1905.         for (slist = elist; slist != NULL; slist = slist->edgenext)
  1906.         {
  1907.             /* assume object's edges are ordered */
  1908.             bg = 0.0;
  1909.             if (!bg && flag && !vert_build(slist->edge->s_pt, bg, 0))
  1910.                 return (Entsp)NULL;
  1911.         }
  1912.         if (!flag && is_tool)
  1913.             do_mac(elist);
  1914.         free(elist);
  1915.         if (flag && !seq_end())
  1916.             return (Entsp)NULL;
  1917.         if (flag)
  1918.         {
  1919.             et = new_entsp();
  1920.             et->nxt = eb;
  1921.             eb = et;
  1922.             ads_entlast(e1);
  1923.             eb->ename[0] = e1[0];
  1924.             eb->ename[1] = e1[1];
  1925.         }
  1926.     }
  1927.     free(llist);
  1928.     ap_del_obj(obj);
  1929.     if (is_tool == -2)
  1930.         return (Entsp)NULL;
  1931.     else
  1932.         return eb;
  1933. }
  1934.  
  1935. /* simulate machining */
  1936.  
  1937. do_mac(elist)
  1938. ap_Edgelist *elist;
  1939. {
  1940.     extern struct resbuf *tool_buf;
  1941.     struct resbuf *assoc_rb(), *trb;
  1942.     ap_Edgelist *slist;
  1943.     ads_point cen, fsp, pt;
  1944.     int i, j, cntr = 5;
  1945.     ads_real rad, theta, inc;
  1946.  
  1947.  
  1948.     ads_command(RTSTR, /*MSG53*/"_.REGEN", NULL);
  1949.     trb = assoc_rb(tool_buf, 10);
  1950.     for (i = 0; i < 3; i++)
  1951.         fsp[i] = trb->resval.rpoint[i] = elist->edge->s_pt[i];
  1952.     ads_entmod(tool_buf);
  1953.     for (slist = elist; slist != NULL; slist = slist->edgenext)
  1954.     {
  1955.         /* assume object's edges are ordered */
  1956.         for (i = 0; i < 3; i++)
  1957.         {
  1958.             if (slist->edgenext)
  1959.                 pt[i] = (-slist->edge->s_pt[i]+slist->edgenext->edge->s_pt[i])/cntr;
  1960.  
  1961.             else
  1962.                 pt[i] = (-slist->edge->s_pt[i]+fsp[i])/cntr;
  1963.         }
  1964.         for (i = 0; i < cntr; i++)
  1965.         {
  1966.             for (j = 0; j < 3; j++)
  1967.                 trb->resval.rpoint[j] += pt[j];    
  1968.             ads_entmod(tool_buf);
  1969.         }
  1970.     }
  1971. }
  1972.  
  1973. /* check if the offset is OK */
  1974.  
  1975. short
  1976. chk_off(e1, e2)
  1977. ads_name e1, e2;
  1978. {
  1979.     ads_name ename, e3;
  1980.     struct resbuf rb, *ebuf, *eb, *assoc_rb();
  1981.     ap_Class class;
  1982.     ap_Objid obj;
  1983.     ads_real zero = 0.0;
  1984.     ads_point p1, p2, p3;
  1985.     ap_Bool fpt = FALSE, spt = FALSE, tpt = FALSE, area = FALSE;
  1986.     short tri_test();
  1987.  
  1988.     /* check if e2 is proper
  1989.         1) if it is closed
  1990.         2) if the points are inside e1/ename or not */
  1991.         
  1992.     p1[2] = p2[2] = p3[2] = -1.0;
  1993.     ebuf = ads_entget(e2);
  1994.     if (!ebuf)
  1995.         return FALSE;
  1996.     eb = assoc_rb(ebuf, 0);
  1997.         if (strcmp(eb->resval.rstring, /*MSG0*/"POLYLINE") != 0)
  1998.                 return FALSE;
  1999.         eb = assoc_rb(ebuf, 70);
  2000.         if (eb->resval.rint == 0) /* not closed */
  2001.                 return FALSE;
  2002.     /* Make the outer one as an object */
  2003.     ads_command(RTSTR, /*MSG54*/"_.COPY", RTENAME, e1, RTSTR, "", RTSTR, "0, 0", RTSTR, "0, 0", NULL);
  2004.     ads_entlast(ename);
  2005.     if (ap_solidify(ename, &obj) != AP_NORMAL)
  2006.         return FALSE;
  2007. #ifdef OLD
  2008.     /* 
  2009.      * Check area now. Write a area computing routine to get rid of
  2010.      * command prompt messages from ACAD 
  2011.          */
  2012.     ads_command(RTSTR, "_.AREA", RTSTR, "_e", RTENAME, e2, NULL);
  2013.     ads_getvar(/*MSG0*/"AREA", &rb);
  2014.     if(c_reqa(&(rb.resval.rreal), &zero, &eps))
  2015.     {
  2016.         ads_command(RTSTR, /*MSG55*/"_.ERASE", RTSTR, "_l", RTSTR, "", NULL);
  2017.         return FALSE;
  2018.     }
  2019. #endif 
  2020.     e3[0] = e2[0]; e3[1] = e2[1];
  2021.     while (ads_entnext(e3, e3) == RTNORM)
  2022.         {
  2023.                 ebuf = ads_entget(e3);
  2024.                 eb = assoc_rb(ebuf, 0);
  2025.                 if (strcmp (eb->resval.rstring, /*MSG0*/"VERTEX") == 0)
  2026.                 {
  2027.                         eb = assoc_rb(eb, 10);
  2028.             if (!fpt) /* B.S. -> compute area */
  2029.             {
  2030.                 Cpoint (p1, eb->resval.rpoint);
  2031.                 fpt = TRUE;
  2032.             }
  2033.             else if (!spt)
  2034.             {
  2035.                 Cpoint (p2, eb->resval.rpoint);
  2036.                 spt = TRUE;
  2037.             }
  2038.             else if (!tpt) 
  2039.             {
  2040.                 Cpoint (p3, eb->resval.rpoint);
  2041.                 tpt = TRUE;
  2042.                 if (tri_test(p1, p2, p3))
  2043.                     area = TRUE;
  2044.             }
  2045.             else if (!area)
  2046.             {
  2047.                 Cpoint (p2, p3);
  2048.                 Cpoint (p3, eb->resval.rpoint);
  2049.                 if (tri_test(p1, p2, p3))
  2050.                     area = TRUE;
  2051.             }
  2052.             /* classify point */
  2053.             trans_euwpt(eb->resval.rpoint, 1, TRUE);
  2054.             if (ap_class_pt(obj, eb->resval.rpoint, &class) != AP_NORMAL)
  2055.             {
  2056.                 ap_del_obj(obj);
  2057.                             ads_relrb(ebuf);
  2058.                 return FALSE;
  2059.             }
  2060.             if (class != AP_INOBJECT)
  2061.             {
  2062.                 ap_del_obj(obj);
  2063.                             ads_relrb(ebuf);
  2064.                 return FALSE;
  2065.             }
  2066.                         
  2067.                 }       
  2068.         else
  2069.                 if (strcmp (eb->resval.rstring, /*MSG0*/"SEQEND") == 0)
  2070.             break;
  2071.         }
  2072.     ap_del_obj(obj);
  2073.     ads_command(RTSTR, /*MSG55*/"_.ERASE", RTENAME, ename, RTSTR, "", NULL);
  2074.         ads_relrb(ebuf);
  2075.     if (!area)
  2076.         return FALSE;
  2077.     return TRUE; 
  2078. }
  2079.  
  2080. /* CHK_SHRINK -- Check the shrink and see if it is valid
  2081.           -- If machined first time 
  2082. */
  2083.  
  2084. short
  2085. chk_shrink(e1, e2)
  2086. ads_name e1, e2;
  2087. {
  2088.    short chk_off(), val;
  2089.    ap_Objid obj;
  2090.    Entsp cde, obj2ply();
  2091.    int test;
  2092.  
  2093.    if (is_tool == -1)
  2094.    {    
  2095.     ads_command (RTSTR, /*MSG56*/"_.erase", RTENAME, e2, RTSTR, "", NULL);
  2096.     ads_printf (/*MSG57*/"Done machining\n");
  2097.     return FALSE;
  2098.    }    
  2099.    val = chk_off(e1, e2);
  2100.    if (!val) /* bad offset */
  2101.    {
  2102.     ads_command (RTSTR, /*MSG58*/"_.erase", RTENAME, e2, RTSTR, "", NULL);
  2103.     if (is_tool == 0) /* from offset command --> complain */ 
  2104.     {
  2105.         ads_printf
  2106.         (/*MSG59*/"\nBad offset. Try a smaller offset distance, parallel UCS, etc. ...\n");
  2107. #ifdef OLD
  2108.         (/*MSG59*/"\nResultant offset is NULL. Try a smaller offset distance...\n");
  2109. #endif
  2110.         is_tool = -1;
  2111.         return FALSE;
  2112.     }
  2113.     if (is_tool > 1)   /* cutting the latter parts recurs till done HACK */
  2114.     {
  2115.         off_dist /= 2.0;
  2116.         test = ads_command (RTSTR, /*MSG60*/"_.offset", RTREAL, off_dist, RTPOINT, plim, RTPOINT, cen, RTSTR, "", NULL);
  2117.             if (test != RTNORM)
  2118.             {
  2119.             ads_printf ("Error in AutoCAD offsetting. Exiting...\n");
  2120.             exit(1);    
  2121.         }
  2122.         ads_entlast(e2);
  2123.         /* do chk_off again */
  2124.            val = chk_off(e1, e2);
  2125.         if (!val)
  2126.         {
  2127.             ads_command (RTSTR, /*MSG61*/"_.erase", RTENAME, e2, RTSTR, "", NULL);
  2128.             is_tool = -1;
  2129.             return FALSE;
  2130.         }
  2131.         /* do tool movement again */
  2132.         if (ap_solidify(e2, &obj) != AP_NORMAL)
  2133.         {
  2134.             off_err();
  2135.             return TRUE;
  2136.         }
  2137.         cde = obj2ply(e2, obj, FALSE); /* tool movement */ 
  2138.         dump_ent(cde);
  2139.         is_tool = -2;
  2140.         return TRUE;
  2141.     }
  2142.     else if (is_tool == 1) /* no need to machine further */
  2143.     {
  2144.         ads_printf
  2145.         (/*MSG62*/"\nObject machined in one pass. No offsetting required...\n");
  2146.         ;
  2147.         /* machine the outer one at least once */
  2148.         /* is_tool = -1; */
  2149.     }
  2150.     return FALSE;
  2151.    }
  2152.    return TRUE;
  2153. }
  2154.  
  2155. /* allocate new Ents */
  2156.  
  2157. Entsp
  2158. new_entsp()
  2159. {
  2160.     Entsp tmp;
  2161.     static char *fname = /*MSG63*/"new_entsp";
  2162.  
  2163.     if((tmp = (Entsp)malloc(sizeof(Ents))) == (Entsp)NULL)
  2164.     {
  2165.         ads_printf(/*MSG64*/"Out of memory...\n");
  2166.         return((Entsp)NULL) ;
  2167.     }
  2168.     tmp->ename[0] = 0L;
  2169.     tmp->ename[1] = 0L;
  2170.     tmp->nxt = (Entsp)NULL;
  2171.     return tmp;
  2172. }
  2173.  
  2174. /*
  2175.  *      Get the equation of a straight line
  2176.  *      passing through the given points.
  2177.  */
  2178.  
  2179. short st_line(pt1, pt2, line)
  2180. Point pt1, pt2;
  2181. Line *line;                            /* equation is ax + by + c = 0 */
  2182. {
  2183.  
  2184. #ifdef __WATCOMC__
  2185.     double xd, yd;
  2186. #else
  2187.     double sqrt(), xd, yd;
  2188. #endif /* WATCOMC */
  2189.  
  2190.         if(requal(pt1.x, pt2.x, EXT_EPS) && requal(pt1.y, pt2.y, EXT_EPS))
  2191.                 return(FALSE);
  2192.         line->x1 = pt1.x;
  2193.         line->y1 = pt1.y;
  2194.         line->x2 = pt2.x;
  2195.         line->y2 = pt2.y;
  2196.     xd = pt2.x - pt1.x;
  2197.     yd = pt2.y - pt1.y;
  2198.     line->len = sqrt((yd*yd) + (xd*xd));
  2199.         if(requal(pt1.x, pt2.x, EXT_EPS))
  2200.         {
  2201.                 line->a = 1.0;
  2202.                 line->b = 0.0;
  2203.                 line->c = - pt1.x;
  2204.                 return(TRUE);
  2205.         }
  2206.         if(requal(pt1.y, pt2.y, EXT_EPS))
  2207.         {
  2208.                 line->a = 0.0;
  2209.                 line->b = 1.0;
  2210.                 line->c = - pt1.y;
  2211.                 return(TRUE);
  2212.         }
  2213.         line->a = - (yd/xd);
  2214.         line->b = 1.0;
  2215.         line->c = - pt2.x * line->a - pt2.y;
  2216.         return(TRUE);
  2217. }
  2218.  
  2219. /*
  2220.  *      Does the point lie on the line segment ?
  2221.  */
  2222.  
  2223. short on_line(line, pt)
  2224. Line line;
  2225. Point pt;
  2226. {
  2227.         double slope1, slope2;
  2228.     short in_between();
  2229.  
  2230.         if(requal(line.x2, line.x1, EXT_EPS) || requal(pt.x, line.x1, EXT_EPS))
  2231.         {
  2232.                 if(requal(line.x2, line.x1, EXT_EPS) &&
  2233.                         requal(pt.x, line.x1, EXT_EPS))
  2234.                 {
  2235.                         if(in_between(line.y1, line.y2, pt.y, EXT_EPS))
  2236.                                 return(TRUE);
  2237.                         else
  2238.                                 return(FALSE);
  2239.                 }
  2240.                 else
  2241.                         return(FALSE);
  2242.         }
  2243.         else
  2244.         {
  2245.                 slope1 = (line.y2 - line.y1) / (line.x2 - line.x1);
  2246.                 slope2 = (pt.y - line.y1) / (pt.x - line.x1);
  2247.                 if(requal(slope1, slope2, EXT_EPS))
  2248.                         if(in_between(line.x1, line.x2, pt.x, EXT_EPS))
  2249.                                 return(TRUE);
  2250.                 return(FALSE);
  2251.         }
  2252. }
  2253.  
  2254. /*
  2255.  *      Check if a number is in between 2 others
  2256.  *      and not equal to either of them.
  2257.  *
  2258.  *      ****    Check if c is between a and b   ******
  2259.  */
  2260.  
  2261. short in_between(a, b, c, eps)
  2262. double a, b, c, eps;
  2263. {
  2264.         if (( c > a && c < b ) || ( c > b && c < a ))
  2265.                 if ( !requal( c, a, eps ) && !requal( c, b, eps ))
  2266.                         return TRUE;
  2267.         return FALSE;
  2268. }
  2269.  
  2270. /* utility function for tangent inverse to handle special cases */ 
  2271.  
  2272. double
  2273. asatan2(x, y)
  2274. double x, y;
  2275. {
  2276. #ifndef __WATCOMC__
  2277.         double atan2(), fabs();
  2278. #endif /* NOT WATCOMC */
  2279.  
  2280.         if ((fabs(x) < 1.0E-20) && (fabs(y) < 1.0E-20))
  2281.                 return ASPI_2;
  2282.         else
  2283.                 return atan2(x, y);
  2284. }
  2285.  
  2286. /* utility function for cosine inverse to handle special cases */ 
  2287.  
  2288. double
  2289. asacos(p)
  2290. double p;
  2291. {
  2292. #ifndef __WATCOMC__
  2293.         double acos();
  2294. #endif /* NOT WATCOMC */
  2295.  
  2296.         if (p > 1.0)
  2297.                 return 0.0;
  2298.         
  2299.         if (p < -1.0)
  2300.                 return ASPI;
  2301.  
  2302.         return acos(p);
  2303. }
  2304.  
  2305. /* utility function to compare two real numbers eqality within the epsilon */
  2306.  
  2307. short
  2308. requal(val1, val2, eps)
  2309. double val1, val2, eps;
  2310. {
  2311.   return (c_reqa(&val1, &val2, &eps));
  2312. }
  2313.  
  2314. /* tri_test() uses the signed_area of a triangle as a test whether
  2315.     three points in a plane are oriented in a CCW or CW direction   */
  2316.  
  2317. short
  2318. tri_test(p1, p2, p3)    /* 2D signed area: if > 0, then p1,p2 and p3 are CCW */
  2319. ads_real *p1, *p2, *p3;
  2320. {
  2321.         ads_real s_area;
  2322.         ads_real zero = 0.0;
  2323.         ads_real epsi;
  2324.         epsi = (ads_real)TRUNC_EPS;
  2325.  
  2326.         s_area = ((p3[0] - p1[0]) * (p2[1] - p3[1]) - (p2[0] - p3[0]) * (p3[1] - p1[1]));
  2327.           /* evaluate the determinant */
  2328.  
  2329.         if (c_reqa (&s_area, &zero, &epsi))
  2330.                 return 0;               /* straight line */
  2331.         if (s_area < 0)
  2332.                         return 1;       /* CCW  */
  2333.         return -1;
  2334. }
  2335.  
  2336. /* EOF */
  2337.