PIXELATE.C

Go to the documentation of this file.

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

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */

/* PIXELATE.C  */

#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>
#include <windows.h>
#include "struct.h"           /* general structures    */
#include "..\common\postprocess\ximage.h"
#include "local.h"

#include "pixelate.h"

#if __X__MIPS__
BOOL WINAPI _CRT_INIT(HINSTANCE ,DWORD , LPVOID );
#endif

static HINSTANCE hDLLinstance=NULL; /* use to pick up resources from DLL  */

#include "utils.h"
#include "paint.c"

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#elif __BC__
BOOL WINAPI DllEntryPoint(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  switch (dwReason) {
    case DLL_PROCESS_ATTACH:
      hDLLinstance = hDLL;  /* handle to DLL file */
      break;
    case DLL_PROCESS_DETACH:
      break;
  }
  return (int)TRUE;
}

static void GetConeR(long x, long y, long r,
                     long Xmax, long Ymax,
                     unsigned char *R,
                     unsigned char *G,
                     unsigned char *B,
                     fullscreenbuffer *S){
 float d,dc=75.0;
 d=dc*((float)rand()/32767.0 - 0.5);
 d += (float)((S+y*Xmax+x)->R);
 d=min(255.0,d);
 d=max(0,d);
 *R=(unsigned char)d;
 d=dc*((float)rand()/32767.0 - 0.5);
 d += (float)((S+y*Xmax+x)->G);
 d=min(255.0,d);
 d=max(0,d);
 *G=(unsigned char)d;
 d=dc*((float)rand()/32767.0 - 0.5);
 d += (float)((S+y*Xmax+x)->B);
 d=min(255.0,d);
 d=max(0,d);
 *B=(unsigned char)d;
 return;
}

static void GetConeC(long x, long y, long r,
                     long Xmax, long Ymax,
                     unsigned char *R,
                     unsigned char *G,
                     unsigned char *B,
                     fullscreenbuffer *S){
 *R=(S+y*Xmax+x)->R;
 *G=(S+y*Xmax+x)->G;
 *B=(S+y*Xmax+x)->B;
 return;
}

static void GetConeA(long x, long y, long r,
                     long Xmax, long Ymax,
                     unsigned char *R,
                     unsigned char *G,
                     unsigned char *B,
                     fullscreenbuffer *S){
 float d,c=0.0,dr=0.0,dg=0.0,db=0.0;
 long  i,j;
 fullscreenbuffer *s;
 for(i=max(x-r,0);i<min(x+r,Xmax-1);i++)
 for(j=max(y-r,0);j<min(y+r,Ymax-1);j++){
   d=sqrt((x-i)*(x-i)+(y-j)*(y-j));
   if(d < (float)r){
     s=(S+j*Xmax+i);
     c  += 1.0;
     dr += (float)s->R;
     dg += (float)s->G;
     db += (float)s->B;
   }
 }
 *R = (unsigned char)(dr/c);
 *G = (unsigned char)(dg/c);
 *B = (unsigned char)(db/c);
 return;
}

static void DrawCone(long x, long y, long r,
                     long Xmax, long Ymax,
                     unsigned char R,
                     unsigned char G,
                     unsigned char B,
                     fullscreenbuffer *S,
                     float            *Z,
                     int type){
 long  i,j;
 float d,z;
 fullscreenbuffer *s;
 for(i=max(x-r,0);i<min(x+r,Xmax-1);i++)
 for(j=max(y-r,0);j<min(y+r,Ymax-1);j++){
   d=sqrt((float)(x-i)*(float)(x-i)+
          (float)(y-j)*(float)(y-j));
   if(d < (float)r){
     z=(r-d);
     if(z > *(Z+j*Xmax+i)){
       s=(S+j*Xmax+i);
//#if 0
       if(type == 1 && r < 4) {
         if((d=fabs(z - *(Z+j*Xmax+i))) < 2.0){
           s->R=(2.0-d)/2.0*255+d/2.0*R;
           s->G=(2.0-d)/2.0*255+d/2.0*G;
           s->B=(2.0-d)/2.0*255+d/2.0*B;
         }
         else{
           s->R=R;
           s->G=G;
           s->B=B;
         }
       }
       else{
//#endif
         s->R=R;
         s->G=G;
         s->B=B;
       }
       *(Z+j*Xmax+i) = z;
     }
   }
 }
 return;
}

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 unsigned char R,G,B;
 long v,x,y,i,j,iRad,Xres,Yres,nXcones,nYcones,type;
 char name_path[255];
 float rad=0.125,*Zb;
 fullscreenbuffer *S,*So;
 sscanf(PrmList,"%s %ld %ld %f",name_path,&v,&type,&rad);
 Xres=lpXimage->Xmax; Yres=lpXimage->Ymax;
 iRad=(long)(rad*(float)Xres);
// iRad=10;
// iRad=40;
 nXcones=Xres/iRad+1;
 nYcones=Yres/iRad+1;

 if(type == 0){
   iRad *= 2.0;  // for crystalize
   nXcones *= 1.5; nYcones *= 1.5;
 }
 else{
   iRad *= 0.5;  // for pointillize
   nXcones *= 1.5; nYcones *= 1.5;
 }

//sprintf(name_path,"Irad=%ld",iRad);
//MessageBox(NULL,name_path,NULL,MB_OK);

 So=(fullscreenbuffer *)X__Malloc(Xres*Yres*(long)sizeof(fullscreenbuffer));
 if(So == NULL){
   MessageBox(GetFocus(),"Memory Out",NULL,MB_OK);
   return 0;
 }
 Zb=(float *)X__Malloc(Xres*Yres*(long)sizeof(float));
 if(So == NULL){
   X__Free(So);
   MessageBox(GetFocus(),"Memory Out",NULL,MB_OK);
   return 0;
 }
 S=lpXimage->Screen;
 memset(So,0xFF,sizeof(fullscreenbuffer)*Xres*Yres);
 for(i=0;i<Xres;i++)for(j=0;j<Yres;j++)*(Zb+j*Xres+i)=0.0;
 for(i=0;i<nXcones;i++)for(j=0;j<nYcones;j++){
   x=(long)(Xres*(float)rand()/32767.0);
   y=(long)(Yres*(float)rand()/32767.0);
   GetConeC(x,y,iRad,Xres,Yres,&R,&G,&B,S);    // At centre
//   GetConeR(x,y,iRad,Xres,Yres,&R,&G,&B,S);  // Random
   DrawCone(x,y,iRad,Xres,Yres,R,G,B,So,Zb,type);
 }

 memcpy(S,So,sizeof(fullscreenbuffer)*Xres*Yres);
 X__Free(So);
 X__Free(Zb);
 return 1;
}

/*************** Function that renders any of the OpenGL Functionality ************/

long _RenderGLexternal(char *PrmList, XIMAGE *lpXimage){
MessageBox(NULL,"OpenGL function called","OK",MB_OK);
 return 1;
}

/*************** +++++++++++++++++++++++++++++++++++++++++++++++++++++ ************/

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

static int version=1;
static long type=0;  // 0=crystalize 1=pointilize
static double radius=0.125;

char * _SetExternalParameters(
  char *Op,                 /* string for the parameters                  */
  HWND hWnd,                /* parent window                              */
  long ruler,               /* ruler scale value to facilitate scaling    */
  char *name,               /* name of DLL file with the effect           */
  X__MEMORY_MANAGER *lpEVI /* pointer to structure with memory functions */
                                    ){
 char buffer[256];
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %f",buffer,&version,&type,&radius);
 }
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_PIXELATE),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 sprintf(buffer,"%s %ld %ld %f",name,version,type,radius);
 if((Op=(char *)CALL_MALLOC(strlen(buffer)+1)) == NULL){
  MessageBox (GetFocus(),"External effect: Out of memory","Error",
                MB_OK|MB_TASKMODAL|MB_ICONSTOP);
   return NULL;
 }
 strcpy(Op,buffer);
 return Op;
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 char str[32];
 BOOL err;
 switch( msg ) {
   case WM_INITDIALOG:
     radius *= 100.0;
     sprintf(str,"%.1f",radius);
     SetDlgItemText(hwnd,DLG_PIXELATE_RADIUS,str);
     if     (type == 0)
       SendDlgItemMessage(hwnd,DLG_PIXELATE_CRYSTAL,BM_SETCHECK,TRUE,0);
     if     (type == 1)
       SendDlgItemMessage(hwnd,DLG_PIXELATE_POINTS,BM_SETCHECK,TRUE,0);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(GetDlgItemText(hwnd,DLG_PIXELATE_RADIUS,str,12) != 0)
            radius=atof(str);
          radius *= 0.01;
          if(SendDlgItemMessage(hwnd,DLG_PIXELATE_CRYSTAL,BM_GETCHECK,0,0))
               type=0;
          else type=1;

          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}