/**
  Set the number of polygons.

  Allocate new polygons or delete polygons (if the number is reduced).
  Setting the number to 0 deletes all polys.

  \param num New number of polys
 */
void PolyhedronGeom::setNumPolys(int num)
{ 
  if (num<0)
    num=0;

  int prevsize = polys.size();
  int i;

  // Delete polygons if the number of polys was decreased
  if (num<prevsize)
  {
    for(i=num; i<prevsize; i++)
    {
      deletePoly(i);
    }
  }

  // Resize poly list
  polys.resize(num);

  // Allocate new polys (which have 1 loop by default)...
  for(i=prevsize; i<num; i++)
  {
    polys[i] = new Poly();
    setNumLoops(i, 1);
  }

  // Update the size constraint for uniform and facevarying variables
  UserSizeConstraint* usc = dynamic_cast<UserSizeConstraint*>(uniformSizeConstraint.get());
  if (usc!=0)
    usc->setSize(num);
  usc = dynamic_cast<UserSizeConstraint*>(faceVaryingSizeConstraint.get());
  if (usc!=0)
    usc->setSize(faceVaryingCount());
}
Example #2
0
int main(int argc, char const *argv[]){
        int i,a,b;
        int tmp;
        Poly li, lp, mulp, sump;
        li = newPoly();
        lp = newPoly();

        if ( NULL == li || NULL == lp)
                return 1;
        li->exp = 0;
        lp->exp = 0;

        srand( time(NULL) );
	for(i = 0 ; i< LSIZE; i++){
                a = rand()/(RAND_MAX/LSIZE);
                b = rand()/(RAND_MAX/LSIZE);
                addItem( a, b, li);
                addItem( b, a, lp);
	}

        //removeDup( li);
        //removeDup( lp);

        printPoly( li );
        printPoly( lp );

        mulp = polyMultiply2( li, lp);
        printf("\nmultiply : " );
        printPoly( mulp );
        deletePoly( mulp);

        sump = polyAdd( li, lp);
        printf("\nadd : " );
        printPoly( sump );
        deletePoly( sump );

        printf("\n li ^2: ");
        printPoly( polyExp(li,2) );

        //swapNext( first(li), li );
        deletePoly( li );
        deletePoly( lp );

	return 0;
}
Example #3
0
/*
 * deallocate memory used by poly. must not use poly after that.
 * if delete_poly==1 then free memory of poly
 */
void deletePoly(Poly *poly, int delete_poly) {
    int i;
    if(poly == NULL) {
        return;
    }
    if(poly->verts != NULL) {
        free(poly->verts);
    }
    if(poly->triangles != NULL) {
        for(i=0; i<poly->num_triangles; i++) {
            deletePoly(poly->triangles+i, 0);
        }
        free(poly->triangles);
    }
    if(poly->normals != NULL) {
        free(poly->normals);
    }
    if(poly->dists != NULL) {
        free(poly->dists);
    }
    if(delete_poly) {
        free(poly);
    }
}
Example #4
0
Filter* getFilter(int (*transform)(void*, Point*, Point*), void *params, int dim_x, int dim_y,
                  Point pt0) {
    Filter *tg;
    Point *t_grid; //transformed grid
    Poly *cell_poly, *poly;
    Vertex *v;
    char *is_transformed;
    int dim;
    float min_x, max_x, min_y, max_y;
    float area;
    int i, j, k;
    int ii, jj;
    int index;
    int last, allocated;

    if(params==NULL)
        return NULL;
    tg=(Filter*)calloc(1, sizeof(Filter));
    tg->dim_x=dim_x;
    tg->dim_y=dim_y;
    tg->x0=pt0.x;
    tg->y0=pt0.y;
    tg->dx=tg->dy=1;
    dim=tg->dim_x*tg->dim_y;
    tg->num_pts=(int*)calloc(dim, sizeof(int));
    tg->pts=(Point**)calloc(dim, sizeof(Point*));
    tg->coefs=(float**)calloc(dim, sizeof(float*));

    // compute the transformed grid (used to get the polygons corresponding to the cells.
    t_grid=(Point*)calloc((tg->dim_x+1)*(tg->dim_y+1), sizeof(Point));
    is_transformed=(char*)calloc((tg->dim_x+1)*(tg->dim_y+1), sizeof(char));
    for(k=0, j=0; j<=tg->dim_y; j++) {
        for(i=0; i<=tg->dim_x; i++, k++) {
            t_grid[k].x=tg->x0+i*tg->dx-tg->dx/2;
            t_grid[k].y=tg->y0+j*tg->dy-tg->dy/2;
            is_transformed[k]=(char)transform(params, t_grid+k, t_grid+k);
            if(is_transformed[k]==-1)
                return NULL; //should never happen!
        }
    }

    //for each cell, get the corresponding polygon, transform it, get all the overlapping cells,
    //(number of overlaping cells=numPoints[k]) and compute percentage of area inside each of these
    // cells
    cell_poly=generatePoly(4);
    cell_poly->verts[0].x=0;
    cell_poly->verts[0].y=1;
    cell_poly->verts[1].x=1;
    cell_poly->verts[1].y=1;
    cell_poly->verts[2].x=1;
    cell_poly->verts[2].y=0;
    cell_poly->verts[3].x=0;
    cell_poly->verts[3].y=0;
    setSides(cell_poly); // verts won't be used from now on, just normals and dists. only update dists
    for(index=0, k=0, j=0; j<tg->dim_y; j++, index++) {
        for(i=0; i<tg->dim_x; i++, k++, index++) {
            if(!(is_transformed[index] &&
                    is_transformed[index+1] &&
                    is_transformed[index+tg->dim_x+1] &&
                    is_transformed[index+tg->dim_x+2]))
                continue;
            if(!is_transformed[index] ||
                    !is_transformed[index+1] ||
                    !is_transformed[index+tg->dim_x+1] ||
                    !is_transformed[index+tg->dim_x+2]) {
                // cell contains border of transformation area.
                // TODO: handle this case
                continue;
            }
            poly=generatePoly(4);
            v=poly->verts;
            v[0].x=t_grid[index+tg->dim_x+1].x;
            v[0].y=t_grid[index+tg->dim_x+1].y;
            v[1].x=t_grid[index+tg->dim_x+2].x;
            v[1].y=t_grid[index+tg->dim_x+2].y;
            v[2].x=t_grid[index+1].x;
            v[2].y=t_grid[index+1].y;
            v[3].x=t_grid[index].x;
            v[3].y=t_grid[index].y;
            if(convexify4(poly)==-1) {
                deletePoly(poly, 1);
                continue;
            }
            setSides(poly);
            computeArea(poly);
            min_x=max_x=v[0].x;
            min_y=max_y=v[0].y;
            for(ii=1; ii<4; ii++) {
                if(v[ii].x<min_x)
                    min_x=v[ii].x;
                else if(v[ii].x>max_x)
                    max_x=v[ii].x;
                if(v[ii].y<min_y)
                    min_y=v[ii].y;
                else if(v[ii].y>max_y)
                    max_y=v[ii].y;
            }
            min_x=floorf(min_x);
            max_x=ceilf(max_x);
            min_y=floorf(min_y);
            max_y=ceilf(max_y);
            allocated=0;
            if((max_x-min_x) > 100 ||(max_y-min_y) > 100) {
                tg->num_pts[k]=1;
                tg->coefs[k]=(float*)calloc(1, sizeof(float));
                tg->pts[k]=(Point*)calloc(1, sizeof(Point));
                tg->coefs[k][0]=1;
                tg->pts[k][0].x=floor((max_x-min_x)/2); //TODO: fix that!
                tg->pts[k][0].y=floor((max_y-min_y)/2);
                deletePoly(poly, 1);
                continue;
            }
            for(jj=(int)min_y; jj<(int)max_y; jj++) {
                for(ii=(int)min_x; ii<(int)max_x; ii++) {
                    cell_poly->dists[0]=jj+1;
                    cell_poly->dists[1]=ii+1;
                    cell_poly->dists[2]=-jj;
                    cell_poly->dists[3]=-ii;
                    area=intersectionArea(poly, cell_poly);
                    if(area<SMALL)
                        continue;
                    last=tg->num_pts[k]++;
                    if(tg->num_pts[k]>allocated) {
                        allocated+=32;
                        tg->coefs[k]=(float*)realloc(tg->coefs[k], allocated*sizeof(float));
                        tg->pts[k]=(Point*)realloc(tg->pts[k], allocated*sizeof(Point));
                    }
                    tg->coefs[k][last]=area/poly->area;
                    tg->pts[k][last].x=ii;
                    tg->pts[k][last].y=jj;
                }
            }
            tg->coefs[k]=(float*)realloc(tg->coefs[k], tg->num_pts[k]*sizeof(float));
            tg->pts[k]=(Point*)realloc(tg->pts[k], tg->num_pts[k]*sizeof(Point));
            deletePoly(poly, 1);
        } //for(i)
    } //for(j)
    free(t_grid);
    free(is_transformed);
    return tg;
}