SHRINK.CPP

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 OpenFX Development Team
-- */

/*  SHRINK.CPP  */

#include "vtk.hh"
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <windows.h>

#define UNIT         32768L
#define DESELECTED       0
#define SELECTED         1
#define INEDITOR         6

#ifdef __cplusplus
extern "C" {
#endif

#include "struct.h"
#include "dstruct.h"

#ifdef __cplusplus
}
#endif

#include "shrink.h"

static long *VidList=NULL,VidMax=0;

class SfxReader : public vtkPolySource
{
public:
  SfxReader();
  ~SfxReader();
  char *GetClassName() {return "SfxReader";};
  int GetNumberOfVertices(void);
  int GetNumberOfEdge(void);
  int GetNumberOfFaces(void);

protected:
  void Execute();
  int  Nv,Nf,Ne;
};

class SfxBaseWriter : public vtkObject
{
public:
  SfxBaseWriter();
  virtual void Write();
  void Update();

protected:
  vtkDataSet *Input;
  virtual void WriteData() = 0;
};

class SfxWriter : public SfxBaseWriter
{
public:
  SfxWriter();
  ~SfxWriter();
  char *GetClassName() {return "SfxWriter";};
  void SetInput(vtkPolyData *input);
  void SetInput(vtkPolyData &input) {this->SetInput(&input);};
  vtkPolyData *GetInput() {return (vtkPolyData *)this->Input;};
  int GetNumberOfVertices(void);
  int GetNumberOfEdge(void);
  int GetNumberOfFaces(void);

protected:
  int Nv,Ne,Nf;
  void WriteData();
  void InsertInVertexList(long , long , long );
  void BuildEdges(long );
  void EraseOldStructure(long );
  void OffsetStructure(long , long , long , long );
};

static HWND      hParent;
static HINSTANCE hThisInstance;

static BOOL CALLBACK SfxDlgProc(HWND hwnd, UINT msg,
                                WPARAM wparam, LPARAM lparam);

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  switch (dwReason) {
    case DLL_PROCESS_ATTACH: {
      hThisInstance=(HINSTANCE)hDLL;
      if(hDLL == NULL)MessageBeep(MB_OK);
      break;
    }
    case DLL_PROCESS_DETACH:
      break;
  }
  return TRUE;
}


extern "C" BOOL _Xmodeler
 (HWND parent_window,HWND info_window,X__STRUCTURE *lpevi){
 HCURSOR hSave;
 static struct bp {
  float f;
 } d;
 lpEVI=lpevi;
 hParent=parent_window;
 d.f=0.8;
 if(DialogBoxParam(hThisInstance,MAKEINTRESOURCE(DLG_VTK),hParent,
             (DLGPROC)SfxDlgProc,(LPARAM)&d) == FALSE)return FALSE;
 hSave=SetCursor(LoadCursor(NULL,IDC_WAIT));
 {
  SfxReader sfxinput;
  SfxWriter sfxoutput;
  vtkShrinkPolyData shrink;

  shrink.SetInput(sfxinput.GetOutput());
  shrink.SetShrinkFactor(d.f);

  sfxoutput.SetInput(shrink.GetOutput());
  sfxoutput.Write();
 }
 SetCursor(hSave);
 return TRUE;
}

static BOOL CALLBACK SfxDlgProc(HWND hwnd, UINT msg,
                          WPARAM wparam, LPARAM lparam){
 BOOL err;
 double f;
 int i;
 static struct bp {
   float f;
 } *dp;
 char str[32];
 switch( msg ) {
   case WM_INITDIALOG:
     dp=(struct bp *)lparam;
     sprintf(str,"%.1lf",dp->f);
     SetDlgItemText(hwnd,DLG_SHRINKFACTOR,(LPCTSTR)str);
     CentreDlgOnS(hwnd);
     return (TRUE);
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(GetDlgItemText(hwnd,DLG_SHRINKFACTOR,str,10) == 0){
            EndDialog(hwnd,FALSE); return TRUE;
          }
          dp->f=atof(str);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

SfxReader::SfxReader()
{
 Nv=Ne=Nf=0;
}

SfxReader::~SfxReader()
{
}

int SfxReader::GetNumberOfVertices(void){return (int)this->Nv;}
int SfxReader::GetNumberOfEdge(void){return (int)this->Ne;}
int SfxReader::GetNumberOfFaces(void){return (int)this->Nf;}

void SfxReader::Execute()
{
  float x[3];
  int i,pts[3],count;
  vtkFloatPoints *newPoints;
  vtkCellArray *newTris;
  vtkPolyData *output = this->GetOutput();
  if(NvertSelect == 0)return;
  newPoints = new vtkFloatPoints(NvertSelect);
  for(count=0,i=0;i<Nvert;i++){
    if((MainVp+i)->status == SELECTED){
      x[0] = (float)((MainVp+i)->xyz[0])/((float)UNIT);
      x[1] = (float)((MainVp+i)->xyz[1])/((float)UNIT);
      x[2] = (float)((MainVp+i)->xyz[2])/((float)UNIT);
      (MainVp+i)->id=count++;
      newPoints->InsertNextPoint(x);
      this->Nv++;
    }
  }
  face *fp;
  for(i=0,count=0;i<Nface;i++){
    fp=(MainFp+i);
    if((MainVp+fp->V[0])->status == SELECTED &&
       (MainVp+fp->V[1])->status == SELECTED &&
       (MainVp+fp->V[2])->status == SELECTED)count++;
  }
  newTris = new vtkCellArray;
  newTris->Allocate(count);
  VidList=(long *)X__Malloc(count*sizeof(long));
  VidMax=count;
  for(i=0;i<Nface;i++){
    fp=(MainFp+i);
    if((MainVp+fp->V[0])->status == SELECTED &&
       (MainVp+fp->V[1])->status == SELECTED &&
       (MainVp+fp->V[2])->status == SELECTED){
      pts[0] = (int)((MainVp+fp->V[0])->id);
      pts[1] = (int)((MainVp+fp->V[1])->id);
      pts[2] = (int)((MainVp+fp->V[2])->id);
      newTris->InsertNextCell(3,pts);
      if(VidList != NULL)VidList[this->Nf]=i;
      this->Nf++;
    }
  }
  output->SetPoints(newPoints);
  newPoints->Delete();
  output->SetPolys(newTris);
  newTris->Delete();
  output->Squeeze();
//MessageBox(NULL,"SfxReader Finished",NULL,MB_OK);
}

SfxBaseWriter::SfxBaseWriter()
{
  this->Input = NULL;
}

void SfxBaseWriter::Write()
{
  if ( !this->Input ) {
    return;
  }
  this->Input->Update();
  this->WriteData();
  this->Input->ReleaseData();
}

void SfxBaseWriter::Update()
{
  this->Write();
}

SfxWriter::SfxWriter()
{
 Nv=0; Ne=0; Nf=0;
}

SfxWriter::~SfxWriter()
{
}

int SfxWriter::GetNumberOfVertices(void){return (int)this->Nv;}
int SfxWriter::GetNumberOfEdge(void){return (int)this->Ne;}
int SfxWriter::GetNumberOfFaces(void){return (int)this->Nf;}

void SfxWriter::SetInput(vtkPolyData *input)
{
  if ( this->Input != input )
    {
    this->Input = (vtkDataSet *) input;
    this->Modified();
    }
}

void SfxWriter::WriteData()
{
  vtkPoints *pts;
  vtkCellArray *polys;
  vtkPolyData *input=(vtkPolyData *)this->Input;

  if ( (pts = input->GetPoints()) == NULL ||
  (polys = input->GetPolys()) == NULL ){
    return;
  }
  vertex *Vp;
  face   *Fp;
  float p[3];
  int i,npts,npolys;
  long BaseVert;
  BaseVert=Nvert;
  npts=input->GetNumberOfPoints();
  npolys=input->GetNumberOfPolys();
  this->Nv=npts;
  this->Nf=npolys;
  if(npts > 0){
    if(!UpdateVertexHeap(Nvert+npts))return;
    for(i=0;i<npts;i++){
      pts->GetPoint(i,p);
      CreateVertex();
      Vp=(MainVp+Nvert-1);
      Vp->id=0;
      Vp->sp=NULL;
      Vp->xyz[0]=(long)(p[0]*(float)UNIT);
      Vp->xyz[1]=(long)(p[1]*(float)UNIT);
      Vp->xyz[2]=(long)(p[2]*(float)UNIT);
    }
  }
  if(npolys > 0){
    int *indx;
    if(!UpdateFaceHeap(Nface+npolys))return;
    for (i=0,polys->InitTraversal(); polys->GetNextCell(npts,indx); i++){
      CreateFace(BaseVert+(long)indx[0],
                 BaseVert+(long)indx[1],
                 BaseVert+(long)indx[2]);
      this->InsertInVertexList(BaseVert,indx[0],indx[1]);
      this->InsertInVertexList(BaseVert,indx[1],indx[2]);
      this->InsertInVertexList(BaseVert,indx[2],indx[0]);
      if(VidList != NULL){
        if(i < VidMax){
          CopyFaceProp((MainFp+VidList[i]),(MainFp+Nface-1));
        }
      }
    }
    this->BuildEdges(BaseVert);
  }
  this->EraseOldStructure(BaseVert);
}

// Use the vertex's skeleton pointer and integer identifer as temporary
// storage for build edge adjacency lists since they are not uses on new
// vertices.
//
void SfxWriter::InsertInVertexList(long base, long Vj, long Vi){
 vertex *vj,*vi;
 long *list,i,j;
 vj=(MainVp+base+Vj);
 vi=(MainVp+base+Vi);
 list = (long *)vi->sp;
 if(vi->id > 0)for(i=0;i<vi->id;i++)if(list[i] == Vj)return;
 list = (long *)vj->sp;
 if(vj->id > 0)for(j=0;j<vj->id;j++)if(list[j] == Vi)return;
 if(vi->id == 0){
   if((list = (long *)X__Malloc((vi->id + 1)*sizeof(long))) == NULL){
     return;
   }
   vi->sp=(struct Designer_SKELETON_tag *)list;
 }
 else{
   list = (long *)vi->sp;
   if((list = (long *)X__Realloc(list,(vi->id + 1)*sizeof(long))) == NULL){
     return;
   }
   vi->sp=(struct Designer_SKELETON_tag *)list;
 }
 list[vi->id] = base+Vj;
 (vi->id)++;
}

void SfxWriter::BuildEdges(long base){
 long n,j,i,*list;
 vertex *vp;
 vp=(MainVp+base);
 for(j=base;j<Nvert;j++){
   if(vp->id != 0 && vp->sp != NULL){
     if(!UpdateEdgeHeap(Nedge+vp->id))return;
     list = (long *)vp->sp;
     for(i=0;i<vp->id;i++)CreateEdge(j,list[i]);
     X__Free(vp->sp); vp->sp=NULL; vp->id=0;
   }
   vp++;
 }
}

void SfxWriter::EraseOldStructure(long base){
 long c;
 vertex *vp;
 vp=(MainVp+base); for(c=base;c<Nvert;c++){
   if(vp->status == SELECTED){
     vp->status=INEDITOR; NvertSelect--; NvertDeselect++;
   }
   vp++;
 }
 EraseVertex(1);
 vp=MainVp; for(c=0;c<Nvert;c++){
   if(vp->status == INEDITOR){
     vp->status=SELECTED; NvertSelect++; NvertDeselect--;
   }
   vp++;
 }
}

void SfxWriter::OffsetStructure(long base, long dx, long dy, long dz){
 long c;
 vertex *vp;
 vp=(MainVp+base); for(c=base;c<Nvert;c++){
   vp->xyz[0] += dx;
   vp->xyz[1] += dy;
   vp->xyz[2] += dz;
   vp++;
 }
}