src/glu/sgi/libnurbs/internals/dataTransform.cc

   1 /*
   2 ** License Applicability. Except to the extent portions of this file are
   3 ** made subject to an alternative license as permitted in the SGI Free
   4 ** Software License B, Version 1.1 (the "License"), the contents of this
   5 ** file are subject only to the provisions of the License. You may not use
   6 ** this file except in compliance with the License. You may obtain a copy
   7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
   8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
   9 **
  10 ** http://oss.sgi.com/projects/FreeB
  11 **
  12 ** Note that, as provided in the License, the Software is distributed on an
  13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
  14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
  15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
  16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
  17 **
  18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
  19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
  20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
  21 ** Copyright in any portions created by third parties is as indicated
  22 ** elsewhere herein. All Rights Reserved.
  23 **
  24 ** Additional Notice Provisions: The application programming interfaces
  25 ** established by SGI in conjunction with the Original Code are The
  26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
  27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
  28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
  29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
  30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
  31 ** published by SGI, but has not been independently verified as being
  32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
  33 **
  34 */
  35 /*
  36 */
  37
  38 #include <stdlib.h>
  39 #include <stdio.h>
  40 #include "glimports.h"
  41 #include "myassert.h"
  42 #include "nurbsconsts.h"
  43 #include "trimvertex.h"
  44 #include "dataTransform.h"
  45
  46 extern directedLine* arcLoopToDLineLoop(Arc_ptr loop);
  47
  48 #if 0 // UNUSED
  49 static directedLine* copy_loop(Arc_ptr loop, Real2* vertArray, int& index, directedLine dline_buf[], sampledLine sline_buf[], int& index_dline)
  50 {
  51   directedLine *ret;
  52   int old_index = index;
  53   int i = index;
  54   int j;
  55   for(j=0; j<loop->pwlArc->npts-1; j++, i++)
  56     {
  57       vertArray[i][0] = loop->pwlArc->pts[j].param[0];
  58       vertArray[i][1] = loop->pwlArc->pts[j].param[1];
  59     }
  60   loop->clearmark();
  61
  62   for(Arc_ptr jarc = loop->next; jarc != loop; jarc=jarc->next)
  63     {
  64       for(j=0; j<jarc->pwlArc->npts-1; j++, i++)
  65         {
  66           vertArray[i][0] = jarc->pwlArc->pts[j].param[0];
  67           vertArray[i][1] = jarc->pwlArc->pts[j].param[1];
  68         }
  69       jarc->clearmark();
  70     }
  71   //copy the first vertex again
  72   vertArray[i][0] = loop->pwlArc->pts[0].param[0];
  73   vertArray[i][1] = loop->pwlArc->pts[0].param[1];
  74   i++;
  75   index=i;
  76
  77   directedLine* dline;
  78   sampledLine* sline;
  79   sline = &sline_buf[index_dline];
  80   dline = &dline_buf[index_dline];
  81   sline->init(2, &vertArray[old_index]);
  82   dline->init(INCREASING, sline);
  83   ret = dline;
  84   index_dline++;
  85
  86   for(i=old_index+1; i<= index-2; i++)
  87     {
  88       sline = &sline_buf[index_dline];
  89       dline = &dline_buf[index_dline];
  90       sline->init(2, &vertArray[i]);
  91       dline->init(INCREASING, sline);
  92       ret->insert(dline);
  93       index_dline++;
  94     }
  95   return ret;
  96 }
  97 #endif
  98
  99 #if 0 // UNUSED
 100 static int num_edges(Bin& bin)
 101 {
 102   int sum=0;
 103   for(Arc_ptr jarc = bin.firstarc(); jarc; jarc=bin.nextarc())
 104     sum += jarc->pwlArc->npts-1;
 105   return sum;
 106 }
 107 #endif
 108
 109 /*
 110 directedLine* bin_to_DLineLoops(Bin& bin)
 111 {
 112   directedLine *ret=NULL;
 113   directedLine *temp;
 114
 115   int numedges = num_edges(bin);
 116   directedLine* dline_buf = new directedLine[numedges]; //not work for N32?
 117   sampledLine* sline_buf=new sampledLine[numedges];
 118
 119   Real2* vertArray = new Real2[numedges*2];
 120   int index = 0;
 121   int index_dline = 0;
 122   bin.markall();
 123
 124   for(Arc_ptr jarc = bin.firstarc(); jarc; jarc=bin.nextarc())
 125     {
 126       if(jarc->ismarked())
 127         {
 128           assert(jarc->check() != 0);
 129           Arc_ptr jarchead = jarc;
 130           do {
 131             jarc->clearmark();
 132             jarc = jarc->next;
 133           } while(jarc != jarchead);
 134           temp=copy_loop(jarchead, vertArray, index, dline_buf, sline_buf, index_dline);
 135           ret = temp->insertPolygon(ret);
 136         }
 137     }
 138
 139   return ret;
 140 }
 141 */
 142
 143
 144 directedLine* bin_to_DLineLoops(Bin& bin)
 145 {
 146   directedLine *ret=NULL;
 147   directedLine *temp;
 148   bin.markall();
 149   for(Arc_ptr jarc=bin.firstarc(); jarc; jarc=bin.nextarc()){
 150     if(jarc->ismarked()) {
 151       assert(jarc->check() != 0);
 152       Arc_ptr jarchead = jarc;
 153       do {
 154         jarc->clearmark();
 155         jarc = jarc->next;
 156       } while(jarc != jarchead);
 157       temp =  arcLoopToDLineLoop(jarc);
 158       ret = temp->insertPolygon(ret);
 159     }
 160   }
 161   return ret;
 162 }
 163
 164 directedLine* o_pwlcurve_to_DLines(directedLine* original, O_pwlcurve* pwl)
 165 {
 166   directedLine* ret = original;
 167   for(Int i=0; i<pwl->npts-1; i++)
 168     {
 169       sampledLine* sline = new sampledLine(2);
 170       sline->setPoint(0, pwl->pts[i].param);
 171       sline->setPoint(1, pwl->pts[i+1].param);
 172       directedLine* dline = new directedLine(INCREASING, sline);
 173       if(ret == NULL)
 174         ret = dline;
 175       else
 176         ret->insert(dline);
 177     }
 178   return ret;
 179 }
 180
 181 directedLine* o_curve_to_DLineLoop(O_curve* cur)
 182 {
 183   directedLine *ret;
 184   if(cur == NULL)
 185     return NULL;
 186   assert(cur->curvetype == ct_pwlcurve);
 187   ret = o_pwlcurve_to_DLines(NULL, cur->curve.o_pwlcurve);
 188   for(O_curve* temp = cur->next; temp != NULL; temp = temp->next)
 189     {
 190       assert(temp->curvetype == ct_pwlcurve);
 191       ret = o_pwlcurve_to_DLines(ret, temp->curve.o_pwlcurve);
 192     }
 193   return ret;
 194 }
 195
 196 directedLine* o_trim_to_DLineLoops(O_trim* trim)
 197 {
 198   O_trim* temp;
 199   directedLine *ret;
 200   if(trim == NULL)
 201     return NULL;
 202   ret = o_curve_to_DLineLoop(trim->o_curve);
 203
 204   for(temp=trim->next; temp != NULL; temp = temp->next)
 205     {
 206       ret = ret->insertPolygon(o_curve_to_DLineLoop(temp->o_curve));
 207     }
 208   return ret;
 209 }