EDGE.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.
-- */

/* EDGE.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 "edge.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:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      hDLLinstance = hDLL;  /* handle to DLL file */
      break;
    case DLL_PROCESS_DETACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      break;
  }
return (int)TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

static void ConvertToGray(long Xres, long Yres,
                          fullscreenbuffer *S){

 unsigned char g;
 long i,j;
 for(i=0;i<Yres;i++){
   for(j=0;j<Xres;j++){
     g=(unsigned char)(((long)S->R+(long)S->G+(long)S->B)/3);
     S->R=g; S->G=g; S->B=g;
     S++;
   }
 }
}

static void Convolve(long Xres, long Yres,
                     fullscreenbuffer *Si,
                     fullscreenbuffer *So,
                     double scale,
                     long bias,
                     long filterX, long filterY,
                     double *filter){
 fullscreenbuffer *S;
 long i,j,k,l,c,r;
 double ar,ag,ab,weight;
 r=filterY/2;
 c=filterX/2;
 for(i=r;i<Yres-r;i++){
   for(j=c;j<Xres-c;j++){
     ar=ag=ab=0.0;
     for(l=0;l<filterY;l++)for(k=0;k<filterX;k++){
       S=(Si+(Xres*(i+(l-r))+(j+(k-c))));
       weight = *(filter+filterX*l+k);
       ar+=(double)S->R*weight;
       ag+=(double)S->G*weight;
       ab+=(double)S->B*weight;
     }
     S=(So+(Xres*i)+j);
     S->R = (unsigned char)max(0.0,(min(255.0,bias+ar*scale)));
     S->G = (unsigned char)max(0.0,(min(255.0,bias+ag*scale)));
     S->B = (unsigned char)max(0.0,(min(255.0,bias+ab*scale)));
   }
 }
}

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 long v,i,j,atype,Xres,Yres;
 long lA,lB,lC,lD,lE,lF,lG,lH,lI,MaxDif,threshold;
 long lineAEIbelow,lineAEIabove,lineAEIdif;
 long lineBEHbelow,lineBEHabove,lineBEHdif;
 long lineCEGbelow,lineCEGabove,lineCEGdif;
 long lineDEFbelow,lineDEFabove,lineDEFdif;
 char name_path[255];
 fullscreenbuffer *s,*S,*So,*Si;
 Xres=lpXimage->Xmax; Yres=lpXimage->Ymax;
 So=(fullscreenbuffer *)X__Malloc(Xres*Yres*(long)sizeof(fullscreenbuffer));
 if(So == NULL){
   MessageBox(GetFocus(),"Memory Out",NULL,MB_OK);
   return 0;
 }
 memcpy(So,lpXimage->Screen,sizeof(fullscreenbuffer)*Xres*Yres);
 sscanf(PrmList,"%s %ld",name_path,&v);
 threshold=16*3;
// threshold=8*3;  // for mixing in edges with original image
 atype=6;
 if(atype == 1){
   memset(So,0,sizeof(fullscreenbuffer)*Xres*Yres);
   for(i=1;i<Yres-1;i++)for(j=1;j<Xres-1;j++){
     Si=(lpXimage->Screen+(Xres*(i-1))+(j-1));
     lA = (long)Si->R + (long)Si->G + (long)Si->B;
     Si=(lpXimage->Screen+(Xres*(i  ))+(j-1));
     lB = (long)Si->R + (long)Si->G + (long)Si->B;
     Si=(lpXimage->Screen+(Xres*(i+1))+(j-1));
     lC = (long)Si->R + (long)Si->G + (long)Si->B;
     Si=(lpXimage->Screen+(Xres*(i-1))+(j  ));
     lD = (long)Si->R + (long)Si->G + (long)Si->B;
     Si=(lpXimage->Screen+(Xres*(i  ))+(j  ));
     lE = (long)Si->R + (long)Si->G + (long)Si->B;
     Si=(lpXimage->Screen+(Xres*(i+1))+(j  ));
     lF = (long)Si->R + (long)Si->G + (long)Si->B;
     Si=(lpXimage->Screen+(Xres*(i-1))+(j+1));
     lG = (long)Si->R + (long)Si->G + (long)Si->B;
     Si=(lpXimage->Screen+(Xres*(i  ))+(j+1));
     lH = (long)Si->R + (long)Si->G + (long)Si->B;
     Si=(lpXimage->Screen+(Xres*(i+1))+(j+1));
     lI = (long)Si->R + (long)Si->G + (long)Si->B;
     lineAEIabove=(lB+lC+lF)/3;
     lineAEIbelow=(lD+lG+lH)/3;
     lineAEIdif=labs(lineAEIbelow-lineAEIabove);
     lineBEHabove=(lC+lF+lI)/3;
     lineBEHbelow=(lA+lD+lG)/3;
     lineBEHdif=labs(lineBEHbelow-lineBEHabove);
     lineCEGabove=(lA+lB+lD)/3;
     lineCEGbelow=(lH+lF+lI)/3;
     lineCEGdif=labs(lineCEGbelow-lineCEGabove);
     lineDEFabove=(lA+lB+lC)/3;
     lineDEFbelow=(lG+lH+lI)/3;
     lineDEFdif=labs(lineDEFbelow-lineDEFabove);
     MaxDif=max(lineAEIdif,lineBEHdif);
     MaxDif=max(lineCEGdif,MaxDif);
     MaxDif=max(lineDEFdif,MaxDif);
     S=(So+(Xres*i)+j);
     if(MaxDif > threshold){
       S->R = (unsigned char)(255.0);
       S->G = (unsigned char)(255.0);
       S->B = (unsigned char)(255.0);
     }
     /*  mixed in edges */
//     S->R = (unsigned char)min(255.0,(double)S->R + 0.005*(double)MaxDif*(double)S->R);
//     S->G = (unsigned char)min(255.0,(double)S->G + 0.005*(double)MaxDif*(double)S->G);
//     S->B = (unsigned char)min(255.0,(double)S->B + 0.005*(double)MaxDif*(double)S->B);
   }
 }
 else if(atype == 3){
   /* blurring */
   double filter[]={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
   Convolve(Xres,Yres,lpXimage->Screen,So,1.0/25.0,0,5,5,filter);
 }
 else if(atype == 4){
   /* laplace edge enhancement */
   double filter[]={0.0,-1.0,0.0,  -1.0,4.0,-1.0,  0.0,-1.0,0.0};
   Convolve(Xres,Yres,lpXimage->Screen,So,1.0,128,3,3,filter);
 }
 else if(atype == 5){
   /* High-Pass Spatial HP3 */
   double filter[]={1.0,-2.0,1.0,  -2.0,5.0,-2.0,  1.0,-2.0,1.0};
   Convolve(Xres,Yres,lpXimage->Screen,So,1.0,128,3,3,filter);
 }
 else if(atype == 2){
   /* High-Pass Spatial HP2 */
   double filter[]={0.0,-1.0,0.0,  -1.0,5.0,-1.0,  0.0,-1.0,0.0};
   Convolve(Xres,Yres,lpXimage->Screen,So,1.0,128,3,3,filter);
 }
 else if(atype == 6){
   /* High-Pass Spatial HP1  for edge enhancement */
   double filter[]={-1.0,-1.0,-1.0,  -1.0,9.0,-1.0,  -1.0,-1.0,-1.0};
   Convolve(Xres,Yres,lpXimage->Screen,So,1.00,128,3,3,filter);
   /* mix in high frequency */
   for(i=1;i<Yres-1;i++)for(j=1;j<Xres-1;j++){
     S=(So+(Xres*i)+j);
     s=(lpXimage->Screen+(Xres*i)+j);
     S->R = (unsigned char)max(0.0,min(255.0,0.80*(double)s->R + 0.40*((double)S->R-128)));
     S->G = (unsigned char)max(0.0,min(255.0,0.80*(double)s->G + 0.40*((double)S->G-128)));
     S->B = (unsigned char)max(0.0,min(255.0,0.80*(double)s->B + 0.40*((double)S->B-128)));
   }
 }
 else if(atype == 7){
   /* Low pass Spatial LP1 */
   double filter[]={0.111111,0.111111,0.111111,
                    0.111111,0.111111,0.111111,
                    0.111111,0.111111,0.111111};
   Convolve(Xres,Yres,lpXimage->Screen,So,1.0,0,3,3,filter);
 }

 memcpy(lpXimage->Screen,So,sizeof(fullscreenbuffer)*Xres*Yres);
 X__Free(So);
 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=0;

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 */
                                    ){
 /* output name and buffer should be as long as necessary to hold full string */
 char buffer[256];
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld",buffer,&version);
 }
 /*   Do the user interface as required to set up the effect, may use a     */
 /*   dialog box etc. Return old string if effect is cancelled (no change)  */
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_EDGE),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 /* Free space occupied by old parameter string */
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 /* print the parameters into the buffer */
 sprintf(buffer,"%s %ld",name,version);
 /* Prepare the output buffer to take copy of parameter list */
 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;
 }
 /* Copy the parameter string to the output buffer */
 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:
#if 0
     SetDlgItemInt(hwnd,DLG_BLUR_SAMPLES,samples,FALSE);
     SetDlgItemInt(hwnd,DLG_BLUR_D1,id1,FALSE);
     if(back == 1)SendDlgItemMessage(hwnd,DLG_BLUR_BACK,BM_SETCHECK,TRUE,0);
     if     (atype == 1)
       SendDlgItemMessage(hwnd,DLG_BLUR_ACC1,BM_SETCHECK,TRUE,0);
     else if(atype == 2)
       SendDlgItemMessage(hwnd,DLG_BLUR_ACC2,BM_SETCHECK,TRUE,0);
     else
       SendDlgItemMessage(hwnd,DLG_BLUR_ACC3,BM_SETCHECK,TRUE,0);
#endif
     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 0
          samples=GetDlgItemInt(hwnd,DLG_BLUR_SAMPLES,&err,FALSE);
          id1=GetDlgItemInt(hwnd,DLG_BLUR_D1,&err,FALSE);
          if(samples < 0)samples=1;
          if(SendDlgItemMessage(hwnd,DLG_BLUR_BACK,BM_GETCHECK,0,0))
               back=1;
          else back=0;
          if   (SendDlgItemMessage(hwnd,DLG_BLUR_ACC3,BM_GETCHECK,0,0))
               atype=3;
          else if(SendDlgItemMessage(hwnd,DLG_BLUR_ACC2,BM_GETCHECK,0,0))
               atype=2;
          else atype=1;
#endif
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}