home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MACRO / CREATEC.M < prev    next >
Text File  |  1996-06-24  |  9KB  |  412 lines
  1. //
  2. //    面接続(Tube)
  3. //
  4. /*
  5. function private MinimumSearch( p1, p2, n1, n2 )
  6. {
  7.     var i, j;
  8.     var len, lenmin, p1min, p2min;
  9.     var tempv[MAXVERTEX];
  10.     p1min = 0;
  11.     p2min = 0;
  12.     lenmin = VertexLength2(p1[0], p2[0]);
  13.     for (i = 0; i < n1; i++) {
  14.         for (j = 0; j < n2; j++) {
  15.             len = VertexLength2(p1[i], p2[j]);
  16.             if (len < lenmin) {
  17.                 lenmin = len;
  18.                 p1min = i;
  19.                 p2min = j;
  20.             }
  21.         }
  22.     }
  23.  
  24.     j = p1min;
  25.     for (i = 0; i < n1; i++) {
  26.         tempv[i] = p1[j];
  27.         j++;
  28.         if (j == n1) j = 0;
  29.     }
  30.     for (i = 0; i < n1; i++) {
  31.         p1[i] = tempv[i];
  32.     }
  33.     j = p2min;
  34.     for (i = 0; i < n2; i++) {
  35.         tempv[i] = p2[j];
  36.         j++;
  37.         if (j == n2) j = 0;
  38.     }
  39.     for (i = 0; i < n2; i++) {
  40.         p2[i] = tempv[i];
  41.     }
  42. }
  43. */
  44. function private MinimumSearch( p1, p2, n1, n2, m1, m2 )
  45. {
  46.     var i, j;
  47.     var len, lenmin, p1min, p2min;
  48.     var tempv[MAXVERTEX];
  49.     var v1[MAXVERTEX], v2[MAXVERTEX];
  50.     for (i = 0; i < n1; i++) {
  51.         v1[i] = unit(Position(p1[i])*m1);
  52.     }
  53.     for (i = 0; i < n2; i++) {
  54.         v2[i] = unit(Position(p2[i])*m2);
  55.     }
  56.  
  57.     p1min = 0;
  58.     p2min = 0;
  59.     lenmin = v1[0] . v2[0];
  60.     for (i = 0; i < n1; i++) {
  61.         for (j = 0; j < n2; j++) {
  62.             len = v1[i] . v2[j];
  63.             if (len > lenmin) {
  64.                 lenmin = len;
  65.                 p1min = i;
  66.                 p2min = j;
  67.             }
  68.         }
  69.     }
  70.  
  71.     j = p1min;
  72.     for (i = 0; i < n1; i++) {
  73.         tempv[i] = p1[j];
  74.         j++;
  75.         if (j == n1) j = 0;
  76.     }
  77.     for (i = 0; i < n1; i++) {
  78.         p1[i] = tempv[i];
  79.     }
  80.     j = p2min;
  81.     for (i = 0; i < n2; i++) {
  82.         tempv[i] = p2[j];
  83.         j++;
  84.         if (j == n2) j = 0;
  85.     }
  86.     for (i = 0; i < n2; i++) {
  87.         p2[i] = tempv[i];
  88.     }
  89. }
  90.  
  91. function private Invert(p1, n1)
  92. {
  93.     var begin,end, temp;
  94.     begin = 1;
  95.     end = n1-1;
  96.     while (begin < end) {
  97.         temp = p1[begin];
  98.         p1[begin] = p1[end];
  99.         p1[end] = temp;
  100.         begin++;
  101.         end--;
  102.     }
  103. }
  104.  
  105. function Tube2Polygon( p1, p2, n1, n2 )
  106. {
  107.     var i;
  108.     var p1c, p2c;
  109.     var p1begin, p1end, p2begin, p2end;
  110.     var v1begin, v1end, v2begin, v2end;
  111.     var v1beginnext, v1endprev, v2beginnext, v2endprev;
  112.  
  113.     var minmult, mult, mintype;
  114.     var vx, vz;
  115.     var p1mat, p2mat;
  116.     var p3mat;
  117.  
  118.     var v1,v2;
  119.     var flag;
  120.  
  121. //    MinimumSearch( p1, p2, n1, n2 );
  122.  
  123.     p1c = vector(0,0,0);
  124.     p2c = p1c;
  125.     for (i = 0; i < n1; i++) {
  126.         p1c += Position(p1[i]);
  127.     }
  128.     p1c = p1c * (1.0 / n1);
  129.     for (i = 0; i < n2; i++) {
  130.         p2c += Position(p2[i]);
  131.     }
  132.     p2c = p2c * (1.0 / n1);
  133.     vz = p2c - p1c;
  134.     vx = Position(p1[0]) - p1c;
  135.  
  136.     p1mat = move(UNIT_MATRIX, p1c * (-1)) / vec(UNIT_MATRIX, vz, vx);
  137.     p2mat = move(UNIT_MATRIX, p2c * (-1)) / vec(UNIT_MATRIX, vz, vx);
  138.  
  139.     MinimumSearch( p1, p2, n1, n2, p1mat, p2mat );
  140.  
  141. /*
  142.     if ((Position(p1[1]) * p1mat) . vector(0,1,0) < 0) {
  143.         Invert(p1, n1);
  144.     }
  145.     if ((Position(p2[1]) * p3mat) . vector(0,1,0) < 0) {
  146.         Invert(p2, n2);
  147.     }
  148. */
  149.     if ( ((Position(p1[0]) * p1mat) * (Position(p1[1]) * p1mat))
  150.        . ((Position(p2[0]) * p2mat) * (Position(p2[1]) * p2mat)) < 0) {
  151.         Invert(p2, n2);
  152.     }
  153.  
  154.  
  155.     p1[n1] = p1[0];
  156.     p2[n2] = p2[0];
  157.  
  158.     p1begin = 0;
  159.     p1end = n1;
  160.     p2begin = 0;
  161.     p2end = n2;
  162.  
  163.     v1begin = unit(Position(p1[0]) * p1mat);
  164.     v1end = v1begin;
  165.     v2begin = unit(Position(p2[0]) * p2mat);
  166.     v2end = v2begin;
  167.  
  168.     PolyVertexs( 3 );
  169.     PolyType( POLY_SIMPLE );
  170.     PolyAttr( AttrCurrent());
  171.     PolyObj( ObjCurrent());
  172.  
  173.     while ( (p1begin < p1end) | (p2begin < p2end) ) {
  174.         minmult = -1;
  175.         mintype = -1;
  176.         if (p1begin < p1end) {
  177.             v1beginnext = unit(Position(p1[p1begin+1]) * p1mat);
  178.             mult = v1beginnext . v2begin;
  179.             if (mult > minmult) {
  180.                 minmult = mult;
  181.                 mintype = 0;
  182.             }
  183.             v1endprev = unit(Position(p1[p1end-1]) * p1mat);
  184.             mult = v1endprev . v2end;
  185.             if (mult > minmult) {
  186.                 minmult = mult;
  187.                 mintype = 1;
  188.             }
  189.         }
  190.         if (p2begin < p2end) {
  191.             v2beginnext = unit(Position(p2[p2begin+1]) * p2mat);
  192.             mult = v2beginnext . v1begin;
  193.             if (mult > minmult) {
  194.                 minmult = mult;
  195.                 mintype = 2;
  196.             }
  197.             v2endprev = unit(Position(p2[p2end-1]) * p2mat);
  198.             mult = v2endprev . v1end;
  199.             if (mult > minmult) {
  200.                 minmult = mult;
  201.                 mintype = 3;
  202.             }
  203.         }
  204.         flag = TRUE;
  205.         if (mintype == 0) {
  206.             if (p2begin < p2end) {
  207.                 v1 = unit(Position(p1[p1begin+1])-Position(p1[p1begin]));
  208.                 v2 = unit(Position(p2[p2begin+1])-Position(p2[p2begin]));
  209.                 if (v1.v2 > 0.999) {
  210.                     PolySetVertex(p1[p1begin], 0);
  211.                     PolySetVertex(p1[p1begin+1], 1);
  212.                     PolySetVertex(p2[p2begin+1], 2);
  213.                     PolySetVertex(p2[p2begin], 3);
  214.                     PolyVertexs( 4 );
  215.                     p2begin++;
  216.                     v2begin = v2beginnext;
  217.                     flag = FALSE;
  218.                 }
  219.             }
  220.             if (flag) {
  221.                 PolySetVertex(p1[p1begin], 0);
  222.                 PolySetVertex(p1[p1begin+1], 1);
  223.                 PolySetVertex(p2[p2begin], 2);
  224.                 PolyVertexs( 3 );
  225.             }
  226.             p1begin++;
  227.             v1begin = v1beginnext;
  228.         } else if (mintype == 1) {
  229.             if (p2begin < p2end) {
  230.                 v1 = unit(Position(p1[p1end-1])-Position(p1[p1end]));
  231.                 v2 = unit(Position(p2[p2end-1])-Position(p2[p2end]));
  232.                 if (v1.v2 > 0.999) {
  233.                     PolySetVertex(p1[p1end], 0);
  234.                     PolySetVertex(p1[p1end-1], 1);
  235.                     PolySetVertex(p2[p2end-1], 2);
  236.                     PolySetVertex(p2[p2end], 3);
  237.                     PolyVertexs( 4 );
  238.                     p2end--;
  239.                     v2end = v2endprev;
  240.                     flag = FALSE;
  241.                 }
  242.             }
  243.             if (flag) {
  244.                 PolySetVertex(p1[p1end], 0);
  245.                 PolySetVertex(p1[p1end-1], 1);
  246.                 PolySetVertex(p2[p2end], 2);
  247.                 PolyVertexs( 3 );
  248.             }
  249.             p1end--;
  250.             v1end = v1endprev;
  251.         } else if (mintype == 2) {
  252.             if (p1begin < p1end) {
  253.                 v1 = unit(Position(p1[p1begin+1])-Position(p1[p1begin]));
  254.                 v2 = unit(Position(p2[p2begin+1])-Position(p2[p2begin]));
  255.                 if (v1.v2 > 0.999) {
  256.                     PolySetVertex(p1[p1begin], 0);
  257.                     PolySetVertex(p1[p1begin+1], 1);
  258.                     PolySetVertex(p2[p2begin+1], 2);
  259.                     PolySetVertex(p2[p2begin], 3);
  260.                     PolyVertexs( 4 );
  261.                     p1begin++;
  262.                     v1begin = v1beginnext;
  263.                     flag = FALSE;
  264.                 }
  265.             }
  266.             if (flag) {
  267.                 PolySetVertex(p2[p2begin], 0);
  268.                 PolySetVertex(p2[p2begin+1], 1);
  269.                 PolySetVertex(p1[p1begin], 2);
  270.                 PolyVertexs( 3 );
  271.             }
  272.             p2begin++;
  273.             v2begin = v2beginnext;
  274.         } else if (mintype == 3) {
  275.             if (p1begin < p1end) {
  276.                 v1 = unit(Position(p1[p1end-1])-Position(p1[p1end]));
  277.                 v2 = unit(Position(p2[p2end-1])-Position(p2[p2end]));
  278.                 if (v1.v2 > 0.999) {
  279.                     PolySetVertex(p1[p1end], 0);
  280.                     PolySetVertex(p1[p1end-1], 1);
  281.                     PolySetVertex(p2[p2end-1], 2);
  282.                     PolySetVertex(p2[p2end], 3);
  283.                     PolyVertexs( 4 );
  284.                     p1end--;
  285.                     v1end = v1endprev;
  286.                     flag = FALSE;
  287.                 }
  288.             }
  289.             if (flag) {
  290.                 PolySetVertex(p2[p2end], 0);
  291.                 PolySetVertex(p2[p2end-1], 1);
  292.                 PolySetVertex(p1[p1end], 2);
  293.                 PolyVertexs( 3 );
  294.             }
  295.             p2end--;
  296.             v2end = v2endprev;
  297.         } else {
  298.             break;
  299.         }
  300.         PolyAppend( TRUE );
  301.         ViewCursor( OFF );
  302.         DrawCurrent( TRUE );
  303.         ViewCursor( ON );
  304.     }
  305. }
  306.  
  307. function TubeMain(sel, pos1, pos2)
  308. {
  309.     var v1[MAXVERTEX], v2[MAXVERTEX], n1, n2, i;
  310.  
  311.     PolyLoad(sel,pos1);
  312.     n1 = PolyVertexs();
  313.     for (i = 0; i < n1; i++) {
  314.         v1[i] = PolyGetVertex(i);
  315.     }
  316.     PolyLoad(sel,pos2);
  317.     n2 = PolyVertexs();
  318.     for (i = 0; i < n2; i++) {
  319.         v2[i] = PolyGetVertex(i);
  320.     }
  321.     Tube2Polygon(v1, v2, n1, n2);
  322.     return TRUE;
  323. }
  324.  
  325. function Tube(sel)
  326. {
  327.     var const POLYMAX = 32;
  328.     var center[POLYMAX], c;
  329.     var flag[POLYMAX];
  330.     var i, j;
  331.     var sels, vers;
  332.     var len, minlen, minp1, minp2;
  333.     var mintype;
  334.     var minpos;
  335.  
  336.     sels = SelectPolygons(sel);
  337.     if (sels < 2 | sels > POLYMAX) {
  338.         Warning();
  339.         if( MESSAGE == ON )
  340.         {
  341.             if( sels < 2 )
  342.                 Message( "接続する面を指定してください" );
  343.             else
  344.                 Message( "接続する面が多すぎます" );
  345.         }
  346.         return FALSE;
  347.     }
  348.  
  349.     SelectAllFalse();
  350.     SelectAll( FALSE );
  351.  
  352.     for (i = 0; i < sels; i++) {
  353.         PolyLoad(sel, i);
  354.         vers = PolyVertexs();
  355.         c = vector(0,0,0);
  356.         for (j = 0; j < vers; j++) {
  357.             c += Position(PolyGetVertex(j));
  358.         }
  359.         center[i] = Vertex(c * (1.0/vers));
  360.         flag[i] = TRUE;
  361.     }
  362.     minlen = VertexLength2(center[0], center[1]);
  363.     minp1 = 0;
  364.     minp2 = 1;
  365.     for (i = 0; i < sels; i++) {
  366.         for (j = i+1; j < sels; j++) {
  367.             len = VertexLength2(center[i], center[j]);
  368.             if (len < minlen) {
  369.                 minlen = len;
  370.                 minp1 = i;
  371.                 minp2 = j;
  372.             }
  373.         }
  374.     }
  375.  
  376.     flag[minp1] = FALSE;
  377.     flag[minp2] = FALSE;
  378.     TubeMain(sel, minp1, minp2);
  379.     while (TRUE) {
  380.         mintype = -1;
  381.         minlen = 999999999;
  382.         for (i = 0; i < sels; i++) {
  383.             if (flag[i]) {
  384.                 len = VertexLength2(center[minp1], center[i]);
  385.                 if (len < minlen) {
  386.                     minlen = len;
  387.                     mintype = 0;
  388.                     minpos = i;
  389.                 }
  390.                 len = VertexLength2(center[minp2], center[i]);
  391.                 if (len < minlen) {
  392.                     minlen = len;
  393.                     mintype = 1;
  394.                     minpos = i;
  395.                 }
  396.             }
  397.         }
  398.         if (mintype == 0) {
  399.             flag[minpos] = FALSE;
  400.             TubeMain(sel, minp1, minpos);
  401.             minp1 = minpos;
  402.         } else if (mintype == 1) {
  403.             flag[minpos] = FALSE;
  404.             TubeMain(sel, minp2, minpos);
  405.             minp2 = minpos;
  406.         } else {
  407.             break;
  408.         }
  409.     }
  410.     return TRUE;
  411. }
  412.