void aplicar_colorizar (int tiempo, int cant_iteraciones, const char *nomb_impl, const char *nomb_arch_entrada, float alpha) {
IplImage *src = 0;
IplImage *dst = 0;
CvSize dst_size;
// Cargo la imagen
if( (src = cvLoadImage (nomb_arch_entrada, CV_LOAD_IMAGE_COLOR)) == 0 )
exit(EXIT_FAILURE);
dst_size.width = src->width;
dst_size.height = src->height;
// Creo una IplImage para cada salida esperada
if( (dst = cvCreateImage (dst_size, IPL_DEPTH_8U, 3) ) == 0 )
exit(EXIT_FAILURE);
typedef void (colorizar_fn_t) (unsigned char*, unsigned char*, int, int, int, int, float);
colorizar_fn_t *proceso;
if (strcmp(nomb_impl, "c") == 0) {
proceso = colorizar_c;
} else {
proceso = colorizar_asm;
}
if (tiempo) {
unsigned long long int start, end;
MEDIR_TIEMPO_START(start);
for(int i=0; i<cant_iteraciones; i++) {
proceso((unsigned char*)src->imageData, (unsigned char*)dst->imageData, src->height, src->width, src->widthStep, dst->widthStep, alpha);
}
MEDIR_TIEMPO_STOP(end);
imprimir_tiempos_ejecucion(start, end, cant_iteraciones);
} else {
proceso((unsigned char*)src->imageData, (unsigned char*)dst->imageData, src->height, src->width, src->widthStep, dst->widthStep, alpha);
}
copiar_bordes_color((unsigned char*)src->imageData, (unsigned char*)dst->imageData, src->height, src->width, src->widthStep);
// Guardo imagen y libero las imagenes
char nomb_arch_salida[256];
memset(nomb_arch_salida, 0, 256);
sprintf(nomb_arch_salida, "%s.colorizar.alpha-%3.2f.%s.bmp", nomb_arch_entrada, alpha, nomb_impl);
cvSaveImage(nomb_arch_salida, dst, NULL);
cvReleaseImage(&src);
cvReleaseImage(&dst);
}
IplImage * aplicar_filtro_juego(IplImage *src, void *param) {
IplImage *srcPrev;
void** p = (void**)param;
IplImage **prev = (IplImage**)(p[0]);
int tolerancia = (int)(p[1]);
srcPrev = cvCloneImage(*prev);
IplImage *out;
if(maxY==0)
maxY=src->height-radioBola;
if(maxX==0)
maxX=src->width-radioBola;
IplImage *ss;
ss=srcPrev;
if(!back)
back=cvLoadImage("images/image3.jpg",CV_LOAD_IMAGE_COLOR);
if(!car)
car=cvLoadImage("images/cosito.jpg",CV_LOAD_IMAGE_COLOR);
if(!ball)
ball=cvLoadImage("images/ball.png",CV_LOAD_IMAGE_COLOR);
out = cvCloneImage( back );
typedef int (buscarPos_fn_t) (unsigned char*, unsigned char*,int, int, int);
buscarPos_fn_t *proceso;
proceso = buscarPos_c;
int pos=proceso((unsigned char*)src->imageData,(unsigned char*)ss->imageData,src->height, src->width, src->widthStep);
pos=src->width-pos;
if(pos<=CAR_RADIO+BORDE)
pos=CAR_RADIO+BORDE;
if(pos>=ANCHO-CAR_RADIO-BORDE)
pos=ANCHO-CAR_RADIO-BORDE;
typedef void (hacerAuto_fn_t) (unsigned char*, unsigned char*,int,int, int, int, int);
hacerAuto_fn_t *proceso2;
proceso2 = hacerAuto_c;
proceso2((unsigned char*)car->imageData,(unsigned char*)out->imageData,pos,src->height, src->width, src->widthStep, car->widthStep);
int posX=prox_ball_x();
int posY=prox_ball_y(pos);
typedef void (hacerPelota_fn_t) (unsigned char*, unsigned char*,int,int,int, int, int, int);
hacerPelota_fn_t *proceso3;
proceso3 = hacerPelota_c;
proceso3((unsigned char*)ball->imageData,(unsigned char*)out->imageData,posX,posY,src->height, src->width, src->widthStep, ball->widthStep);
cvReleaseImage(&ss);
cvReleaseImage(&car);
cvReleaseImage(&back);
return out;
}
int main()
{
int opc;
int matriz[][3] = {{1,2,3},{4,5,6}};
system("pause");
opc = menuMat();
while(proceso(opc, matriz) ) // Chequeo lo que devuelve proceso.
{
opc = menuMat();
}
return 0;
}
int main()
{
int pid;
int status;
int shmidG, shmidSEM;
int args[3];
int i;
void *thread_result;
// Declarar memoria compartida
shmidG=shmget(0x1234,sizeof(g),0666|IPC_CREAT);
shmidSEM=shmget(0x1235, sizeof(mySem),0666|IPC_CREAT);
if(shmidG==-1 || shmidSEM==-1)
{
perror("Error en la memoria compartida\n");
exit(1);
}
g=shmat(shmidG,NULL,0);
mySem=shmat(shmidSEM,NULL,0);
if(g==NULL || mySem==NULL)
{
perror("Error en el shmat\n");
exit(2);
}
*g=0;
initsem(mySem, 1);
srand(getpid());
for(i=0;i<3;i++)
{
// Crea un nuevo proceso hijo que ejecuta la función proceso()
pid=fork();
if(pid==0)
proceso(i);
}
for(i=0;i<3;i++)
pid = wait(&status);
// Eliminar la memoria compartida
shmdt(g);
shmdt(mySem);
}
int interprete()
{
int _status=reservedptr("status");
// PROVISIONAL. Se tendra que cambiar para k soporte frame(int) y prioritys
if ( num_proc_orden > 0 )
{
for ( proceso_actual = 0 ; proceso_actual < num_proc_orden ; proceso_actual++ )
{
if(procs_s[proc_orden[proceso_actual]].tipo==0 || mem[procs_s[proc_orden[proceso_actual]].id+_status]==2)
proceso( proc_orden[ proceso_actual ], -1 ) ;
}
/* El texto "en el aire" no se muestra nunca */
memb[nullstring[0]*4]=0;
memb[nullstring[1]*4]=0;
memb[nullstring[2]*4]=0;
memb[nullstring[3]*4]=0;
Call_Entrypoint(EDIV_frame);
for ( proceso_actual = 0 ; proceso_actual < num_proc_orden ; proceso_actual++ )
{
//printf("Proceso %d - Estado: %d\n",procs_s[proc_orden[proceso_actual]].id,mem[procs_s[proc_orden[proceso_actual]].id+_status]);
if(mem[procs_s[proc_orden[proceso_actual]].id+_status]==1) {
mem[procs_s[proc_orden[proceso_actual]].id+_status]=0;
lista_quita(proceso_actual);
proceso_actual--;
}
}
}
else {
stub_quit(0) ;
}
return 1 ;
}
int main()
{
int pid;
int status;
int shmid;
int args[3];
int i;
void *thread_result;
key = 1234;
msgflg = IPC_CREAT|0666;
if((msgqid = msgget(key, msgflg)) < 0)
{
perror("msgget failed");
exit(1);
}
mensaje.mtype = 1;
strcpy(mensaje.mtext, "OK");
if(msgsnd(msgqid, &mensaje, MSG_SIZE, IPC_NOWAIT) < 0)
{
perror("msgsnd failed");
exit(1);
}
srand(getpid());
for(i=0; i<3; i++)
{
// Crea un nuevo proceso hijo que ejecuta la función proceso()
pid=fork();
if(pid==0)
proceso(i);
}
for(i=0; i<3; i++)
pid = wait(&status);
// Eliminar la memoria compartida
}
int main (int argc,char **argv) {
time_t temps;
struct tm t;
temps = time(NULL);
localtime_r(&temps, &t);
int i = 0;
char dir_actual[MAXLONG];
acabados = 0;
bmount(DISK_NAME);
signal(SIGCHLD,reaper);
// printf("Llistam contingut abans de començar: \n");
// mi_ls2();
// printf("Esperant 2 segons abans de començar... \n");
// sleep(2);
// cleanup();
sprintf(dir_actual, "simul_%d%d%d", t.tm_hour, t.tm_min, t.tm_sec);
for (i = 0;i<PROCESOS; i++) {
// if(fork() == 0) {
proceso(dir_actual, i);
// exit(0);
// }
sleep(1);
}
// while (acabados<PROCESOS)
// pause();
printf("Llistam contingut després d'haver acabat: \n");
mi_ls2();
bumount(DISK_NAME);
}
int main()
{
int pid;
int status;
int shmid, shmidgwait, shmidgsig;
int args[3];
int i;
printf("inicio\n");
fflush(stdout);
// definir la memoria compartida
shmid=shmget(0x1234,sizeof(sem),0666|IPC_CREAT);
shmidgwait=shmget(0x1250,sizeof(gwait),0666|IPC_CREAT);
shmidgsig=shmget(0x1275,sizeof(gsig),0666|IPC_CREAT);
printf("pase el shmget \n");
fflush(stdout);
if(shmid==-1 || shmidgwait==-1 || shmidgsig==-1)
{
perror("Error en la memoria compartida\n");
exit(1);
}
// Declarar el semaforo en memoria compartida
sem = shmat(shmid,NULL,0);
// declarar las exchanges
gwait = shmat(shmidgwait,NULL,0);
gsig =shmat(shmidgsig,NULL,0);
if(sem == NULL || gwait == NULL || gsig == NULL)
{
perror("Error en el shmat\n");
exit(2);
}
// inciializa el semaforo y los xchnges
initsem(sem, WAYS);
*gwait = 0;
*gsig = 0;
printf("iniciamos nuestro semanforo, gwait=%d, gsig=%d\n", *gwait, *gsig);
fflush(stdout);
srand(getpid()); // random seed con el pid del padre
for(i=0;i<3;i++)
{
// Crea un nuevo proceso hijo que ejecuta la función proceso()
pid=fork();
if(pid==0){
printf("\n entramos a proceso: %d", i);
fflush(stdout);
proceso(i, pid);
}
}
for(i=0;i<3;i++)
pid = wait(&status);
// Eliminar la memoria compartida
shmdt(sem);
shmdt(gwait);
shmdt(gsig);
}
int main() {
proceso().principal();
return 0;
}
int main (int argc,char **argv) {
if (argc == 2) {
signal(SIGCHLD,reaper);
mount(argv[1]);
struct inodo in;
if (leer_inodo(&in, 0) < 0) {
printf("ERROR (simulacion.c -> mi_stat(/)): Error al leer el estado\n");
}
struct superbloque SB;
if (bread(0, (char *)&SB) < 0) {
printf("ERROR (simulacion.c -> error al leer el superbloque)\n");
}
if (in.t_bytes > 0) {
vaciar();
initSB(SB.n_bloques, argv[1]);
initMB(SB.n_bloques);
initAI(SB.n_bloques);
}
int i;
for (i = 0; i < N_PROCESOS; i++) {
int hilo = fork();
if (hilo == 0) {
if (proceso(i) < 0) {
printf("ERROR (simulacion.c): Error al crear el proceso %d.\n", i);
return (-1);
}
exit(0);
}
else if (hilo < 0) {
i--;
printf("Llamamos al reaper, hilo = %d\n", hilo);
reaper();
}
sleep(1);
}
while (acabados < N_PROCESOS) {
pause();
}
unmount(argv[1]);
}
else {
printf("ERROR (simulacion.c): Error, parámetros != de 2 (%d).\n", argc);
return (-1);
}
return (0);
}
void aplicar_decode (const char *implementacion,
const char *archivo_entrada,
bool verbose)
{
const int long_texto=10000;
unsigned char mensaje_salida[long_texto];
IplImage *src = 0;
IplImage *dst = 0;
// Cargo la imagen
if( (src = cvLoadImage (archivo_entrada, CV_LOAD_IMAGE_COLOR)) == 0 )
exit(EXIT_FAILURE);
// Creo una IplImage para cada salida esperada
if( (dst = cvCreateImage (cvGetSize (src), IPL_DEPTH_8U, 1) ) == 0 )
exit(EXIT_FAILURE);
typedef void (decode_t) (unsigned char*, unsigned char*, int, int, int);
decode_t *proceso;
if (strcmp(implementacion, "c") == 0) {
proceso = decode_c;
} else {
proceso = decode_asm;
}
FILE* f = fopen(DECODE_TIEMPOS, "a");
int iteraciones = 1;
long int total = 0;
for (int r = 0; r <= 99; r++){
int tiempo = 0;
int start = 0;
int stop = 0;
MEDIR_TIEMPO_START(start);
proceso((unsigned char*)src->imageData, (unsigned char*)mensaje_salida, long_texto, src->width, src->height);
MEDIR_TIEMPO_STOP(stop);
tiempo = stop - start;
total = total + tiempo;
fprintf(f, "%d %d %ld\n", iteraciones, tiempo, total);
iteraciones ++;
}
FILE* g = fopen(DECODE_TOTALES, "a");
fprintf(g,"%ld\n", total);
fclose(g);
fclose(f);
promedio = promedio + (total / global);
// Guardo imagen y libero las imagenes
char filename[255];
sprintf(filename,"%s.mensaje.%s.txt",archivo_entrada,implementacion);
FILE* decoded_txt = fopen(filename,"w");
mensaje_salida[long_texto-1]='\0';
fprintf(decoded_txt,"%s",mensaje_salida);
fclose(decoded_txt);
// printf ( " Salida en : %s\n", filename);
cvReleaseImage(&src);
cvReleaseImage(&dst);
}
void aplicar_filtro_color (const char *implementacion,
const char *archivo_entrada,
bool verbose, bool frames,
const char *carpeta_frames,
int rc, int gc, int bc,
int threshold) {
static size_t bufsize = 1024;
char namebuff[bufsize + 1];
const char *filename = basename(archivo_entrada);
CvCapture *srcVid = abrir_video(archivo_entrada);
CvSize dst_size;
dst_size.width = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FRAME_WIDTH);
dst_size.height = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FRAME_HEIGHT);
double fps = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FPS);
int nchannels = 3;
typedef struct CvVideoWriter CvVideoWriter;
CvVideoWriter* dstVid = NULL;
if (!frames) {
snprintf(namebuff, bufsize, "%s.fcolor.avi", archivo_entrada);
dstVid = abrir_writer(namebuff, fps, dst_size);
}
/* Armo la imagen destino. */
IplImage *dst = NULL;
dst = cvCreateImage (dst_size, IPL_DEPTH_8U, nchannels);
if (dst == NULL) {
fprintf(stderr, "Error armando la imagen destino\n");
exit(EXIT_FAILURE);
}
if (verbose) {
cvNamedWindow("procesanding", CV_WINDOW_AUTOSIZE);
}
unsigned int framenum = 0;
FILE* f = fopen(COLOR_TIEMPOS, "a");
int iteraciones = 1;
long int total = 0;
while(1) {
/* Capturo un frame */
IplImage *frame = cvQueryFrame(srcVid);
framenum ++;
if (frame == NULL) {
break;
}
/* Aplico el filtro */
typedef void (fcolor_fn_t) (unsigned char*, unsigned char*,
unsigned char, unsigned char,
unsigned char, int, int, int);
fcolor_fn_t *proceso;
if (strcmp(implementacion, "c") == 0) {
proceso = color_filter_c;
} else {
proceso = color_filter_asm;
}
int stop = 0;
int start = 0;
int tiempo = 0;
MEDIR_TIEMPO_START(start);
proceso((unsigned char *) frame->imageData,
(unsigned char *) dst->imageData, rc, gc, bc, threshold,
frame->height, frame->width);
MEDIR_TIEMPO_STOP(stop);
tiempo = stop - start;
total = tiempo + total;
fprintf(f, "%d %d %ld\n", iteraciones, tiempo, total);
iteraciones ++;
if (frames) {
/* Escribo el frame */
snprintf(namebuff, bufsize, "%s/%s.fcolor.%d.bmp",
carpeta_frames, filename, framenum);
cvSaveImage(namebuff, dst, NULL);
} else {
cvWriteFrame(dstVid, dst);
}
if (verbose) {
cvShowImage("procesanding", dst);
cvWaitKey(1);
}
}
FILE* g = fopen(COLOR_TOTALES, "a");
fprintf(g,"%ld\n", total);
fclose(g);
promedio = promedio + (total / global);
fclose(f);
if (verbose) {
cvDestroyWindow("procesanding");
}
cvReleaseImage(&dst);
if (!frames) {
cvReleaseVideoWriter(&dstVid);
}
cvReleaseCapture(&srcVid);
}
int proceso( int num, int padre )
{
int v1 ;
int retcode = 0;
int no_devuelve = 0 ;
int (*externa)(struct _fun_params*);
int temp,oo;
unsigned int utemp;
int cpas=0;
#ifdef DBG
int actual_lin;
#endif
int _status=reservedptr("status");
int _param_offset;
num_proc = num ;
imem = procs_s[num_proc].imem ;
//printf("num_proc: %d\n",num);
while( retcode == 0 )
{
//printf("imem: %i\tnum_proc: %i\tsp: %i\tpila[sp]: %i \n" , imem , num_proc , sp , pila[sp]) ;
switch ( mem[ imem++ ] )
{
case lnop://0
break;
case lcar://1
pila[++sp]=mem[imem++] ;
break;
case lasi://2
mem[ pila[sp-1] ] = pila[sp--] ;
//printf("Cargado %i en %i\n" , pila[sp+1], pila[sp] ) ;
break ;
case lori://3
pila[sp-1]|=pila[sp];
sp--;
break;
case lxor://4
pila[sp-1]^=pila[sp];
sp--;
break;
case land://5
pila[sp-1]&=pila[sp];
sp--;
break;
case ligu://6
pila[sp-1] = ( pila[sp-1] == pila[sp] ) ;
sp--;
break;
case ldis://7
pila[sp-1] = ( pila[sp-1] != pila[sp] ) ;
sp--;
break;
case lmay://8
pila[sp-1] = ( pila[sp-1] > pila[sp] ) ;
sp--;
break;
case lmen://9
pila[sp-1] = ( pila[sp-1] < pila[sp] ) ;
sp--;
break;
case lmei://10
pila[sp-1] = ( pila[sp-1] <= pila[sp] ) ;
sp--;
break;
case lmai://11
pila[sp-1] = ( pila[sp-1] >= pila[sp] ) ;
sp--;
break;
case ladd://12
pila[sp-1] += pila[sp] ;
sp--;
break;
case lsub://13
pila[sp-1] -= pila[sp] ;
sp--;
break;
case lmul://14
pila[sp-1] *= pila[sp] ;
sp--;
break;
case ldiv://15
if(pila[sp]==0) error(145); // división entre cero
pila[sp-1] /= pila[sp] ;
sp--;
break;
case lmod://16
if(pila[sp]==0) error(145); // división entre cero
pila[sp-1] %= pila[sp] ;
sp--;
break;
case lneg://17
pila[sp] = -pila[sp] ;
break ;
case lptr://18
pila[sp] = mem[ pila[sp] ] ;
break ;
case lnot://19
pila[sp]^=-1;
break ;
case laid://20
pila[sp]+= procs_s[num_proc].id ;
break ;
case lcid://21
pila[++sp] = procs_s[num_proc].id ;
break ;
case lrng://22 POR HACER (debug)
imem++;
break ;
case ljmp://23
imem = mem[ imem ] ;
//printf("Nueva posicion: %i\n", imem ) ;
break ;
case ljpf://24
if (!(pila[sp]&1))
imem = mem[ imem ] ;
else
imem++;
sp--;
break ;
case lfun://25 NO USADO
break ;
case lcal://26
devolver++ ;
v1 = busca_proc_libre() ;
procs_s[v1].imem = mem[imem++] ;
temp = proceso_actual ;
proceso_actual = lista_mete(v1) ;
procs_s[num_proc].imem = imem ;
proceso(v1,num_proc) ;
proceso_actual = temp ;
num_proc = num ;
imem = procs_s[num_proc].imem ;
break ;
case lret://27
lista_quita(proceso_actual);
//printf("Ret: %i\n" , num_proc) ;
retcode = 1 ;
break ;
case lasp://28
sp--;
break;
case lfrm://29
procs_s[num_proc].imem = imem ;
reserved("type_scan",procs_s[num_proc].id)=0; /* resetea get_id() */
reserved("id_scan",procs_s[num_proc].id)=0;
if ( first_loaded )
{
Call_Entrypoint(EDIV_first_load);
first_loaded = 0 ;
}
//printf("Frame en: %i\n" , imem ) ;
retcode = 1 ;
break ;
case lcbp://30
reserved("parameters",procs_s[num_proc].id)=mem[imem++];
reserved("param_offset",procs_s[num_proc].id)=sp-reserved("parameters",procs_s[num_proc].id)+1;
/**/procs_s[num_proc].num_params = mem[ imem-1 ] ;
break;
case lcpa://31
mem[pila[sp]]=pila[reserved("param_offset",procs_s[num_proc].id)++];
sp--;
cpas++;
if(cpas==reserved("parameters",procs_s[num_proc].id))
sp-=cpas;
break;
case ltyp://32
if ( procs_s[num_proc].tipo != 0 ) {
critical_error(3); // redefinición del tipo de proceso
}
procs_s[num_proc].id = (mem[2] + ( num_proc * iloc_len ))|1;
if(procs_s[num_proc].id>imem_max-iloc_len)
critical_error(8); // demasiados procesos en ejecución
memcpy(&mem[procs_s[num_proc].id],&mem[iloc],iloc_pub_len<<2);
reserved("process_id",procs_s[num_proc].id)=procs_s[num_proc].id;
if(padre!=-1) {
int bigbro;
if(bigbro=local("son",procs_s[padre].id)) {
local("smallbro",bigbro)=procs_s[num_proc].id;
local("bigbro",procs_s[num_proc].id)=bigbro;
}
local("son",procs_s[padre].id)=procs_s[num_proc].id;
local("father",procs_s[num_proc].id)=procs_s[padre].id;
}
else {
local("father",procs_s[num_proc].id)=0;
}
procs_s[num_proc].tipo = mem[ imem++ ] ;
reserved("process_type",procs_s[num_proc].id) = procs_s[num_proc].tipo ;
mem[procs_s[num_proc].id+_status] = 2;
inicio_privadas=mem[6];
break ;
case lpri://33 POR HACER?
memcpy(&mem[procs_s[num_proc].id+inicio_privadas],&mem[imem+1],(mem[imem]-imem-1)<<2);
inicio_privadas+=(mem[imem]-imem-1); imem=mem[imem];
break ;
case lcse://34
if ( pila[sp-1] == pila[sp] )
imem++;
else
imem=mem[imem];
sp--;
break ;
case lcsr://35
if ( pila[sp-2] >= pila[sp-1] && pila[sp-2] <= pila[sp] )
imem++ ;
else
imem = mem[imem];
sp-=2;
break ;
case lshr://36
pila[sp-1] >>= pila[sp] ;
sp-- ;
break ;
case lshl://37
pila[sp-1] <<= pila[sp] ;
sp-- ;
break ;
case lipt://38
pila[sp] = ++mem[ pila[sp] ] ;
break ;
case lpti://39 COMPORTAMIENTO EXTRAÑO SI SE PONE EN UNA LINEA
mem[ pila[sp] ]++;
pila[sp] = mem[ pila[sp] ]-1 ;
break ;
case ldpt://40
pila[sp] = --mem[ pila[sp] ] ;
break ;
case lptd://41 COMPORTAMIENTO EXTRAÑO SI SE PONE EN UNA LINEA
mem[ pila[sp] ]--;
pila[sp] = mem[ pila[sp] ]+1 ;
break ;
case lada://42
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] += pila[sp] ;
sp--;
break;
case lsua://43
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] -= pila[sp] ;
sp--;
break;
case lmua://44
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] *= pila[sp] ;
sp--;
break;
case ldia://45
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] /= pila[sp] ;
sp--;
break;
case lmoa://46
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] %= pila[sp] ;
sp--;
break;
case lana://47
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] &= pila[sp] ;
sp--;
break;
case lora://48
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] |= pila[sp] ;
sp--;
break;
case lxoa://49
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] ^= pila[sp] ;
sp--;
break;
case lsra://50
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] >>= pila[sp] ;
sp--;
break;
case lsla://51
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] <<= pila[sp] ;
sp--;
break;
case lpar://52 POR HACER?
//imem++;
inicio_privadas+=mem[imem++];
break;
case lrtf://53
lista_quita(num_proc) ;
no_devuelve = 1 ;
//printf("Return: %i\n" , num_proc) ;
retcode = 1 ;
break ;
case lclo://54 POR HACER
break ;
case lfrf://55 POR HACER
sp--;
break ;
case limp://56
carga_dll((char*)&mem[mem[imem++]]);
break ;
case lext://57
externa=extfuncs[mem[imem]];
// corresponder con FUNCTION_PARAMS
//temp = externa(pila,&sp,mem,varindex,&procs_s,Call_Entrypoint);
fp.num_params=extparms[mem[imem++]];
temp = externa(&fp) ;
pila[++sp]= temp ;
break ;
case ldbg://58
#ifdef DBG
Call_Entrypoint(EDIV_debug,imem,nombre_program,lin,0);
#endif
break ;
/* OPCODES OPTIMIZADOS */
case lcar2://60
pila[++sp]=mem[imem++];
pila[++sp]=mem[imem++];
break;
case lcar3://61
pila[++sp]=mem[imem++];
pila[++sp]=mem[imem++];
pila[++sp]=mem[imem++];
break;
case lcar4://62
pila[++sp]=mem[imem++];
pila[++sp]=mem[imem++];
pila[++sp]=mem[imem++];
pila[++sp]=mem[imem++];
break;
case lasiasp://63
mem[pila[sp-1]]=pila[sp];
sp-=2;
break;
case lcaraid://64
pila[++sp]=mem[imem++]+procs_s[num_proc].id;
break;
case lcarptr://65
pila[++sp]=mem[mem[imem++]];
break;
case laidptr://66
pila[sp]=mem[pila[sp]+procs_s[num_proc].id];
break;
case lcaraidptr://67
pila[++sp]=mem[mem[imem++]+procs_s[num_proc].id];
break;
case lcaraidcpa://68
mem[mem[imem++]+procs_s[num_proc].id]=pila[reserved("param_offset",procs_s[num_proc].id)++];
//sp--;
cpas++;
if(cpas==reserved("parameters",procs_s[num_proc].id))
sp-=cpas;
break;
case laddptr://69
pila[sp-1]=mem[pila[sp-1]+pila[sp]];
sp--;
break;
case lfunasp://70 NO USADO
break;
case lcaradd://71
pila[sp]+=mem[imem++];
break;
case lcaraddptr://72
pila[sp]=mem[pila[sp]+mem[imem++]];
break;
case lcarmul://73
pila[sp]*=mem[imem++];
break;
case lcarmuladd://74
pila[sp-1]+=pila[sp]*mem[imem++];
sp--;
break;
case lcarasiasp://75
mem[pila[sp]]=mem[imem++];
sp--;
break;
case lcarsub://76
pila[sp]-=mem[imem++];
break;
case lcardiv://77 no hay nunca "cardiv 0"
pila[sp]/=mem[imem++];
break;
/* OPERACIONES CON DATOS DE TIPO BYTE */
case lptrchr:
pila[sp-1]=(unsigned int)memb[pila[sp-1]*4+pila[sp]];
sp--;
break;
case lasichr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]=(byte)pila[sp]);
sp-=2;
break;
case liptchr:
pila[sp-1]=(unsigned int)++memb[pila[sp-1]*4+pila[sp]];
sp--;
break;
case lptichr:
/* o_O yo lo flipo con el visual studio! mirad la tonteria que he
* tenido ke hacer! (variable utemp)
* visto lo visto, hay que testear cuidadosamente TODOS los opcodes!
*/
utemp=pila[sp-1];
pila[sp-1]=(unsigned int)memb[utemp*4+pila[sp]]++;
sp--;
break;
case ldptchr:
pila[sp-1]=(unsigned int)--memb[pila[sp-1]*4+pila[sp]];
sp--;
break;
case lptdchr:
/* y aqui la misma chapuza en teoria innecesaria! */
utemp=pila[sp-1];
pila[sp-1]=(unsigned int)memb[utemp*4+pila[sp]]--;
sp--;
break;
case ladachr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]+=(byte)pila[sp]);
sp-=2;
break;
case lsuachr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]-=(byte)pila[sp]);
sp-=2;
break;
case lmuachr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]*=(byte)pila[sp]);
sp-=2;
break;
case ldiachr:
/*#ifdef DBG
if (pila[sp]==0) {
memb[pila[sp-2]*4+pila[sp-1]]=0;
sp-=2; pila[sp]=0;
v_function=-2; e(145);
if (call_to_debug) { process_stoped=id; return; }
break;
}
#endif*/
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]/=(byte)pila[sp]);
sp-=2;
break;
case lmoachr:
/*#ifdef DBG
if (pila[sp]==0) {
memb[pila[sp-2]*4+pila[sp-1]]=0;
sp-=2; pila[sp]=0;
v_function=-2; e(145);
if (call_to_debug) { process_stoped=id; return; }
break;
}
#endif*/
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]%=(byte)pila[sp]);
sp-=2;
break;
case lanachr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]&=(byte)pila[sp]);
sp-=2;
break;
case lorachr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]|=(byte)pila[sp]);
sp-=2;
break;
case lxoachr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]^=(byte)pila[sp]);
sp-=2;
break;
case lsrachr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]>>=(byte)pila[sp]);
sp-=2;
break;
case lslachr:
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]<<=(byte)pila[sp]);
sp-=2;
break;
case lcpachr:
_param_offset=reservedptr("param_offset");
if ((unsigned int)pila[mem[procs_s[num_proc].id+_param_offset]]<256) {
memb[pila[sp-1]*4+pila[sp]]=(byte)pila[mem[procs_s[num_proc].id+_param_offset]];
}
else {
if (pila[mem[procs_s[num_proc].id+_param_offset]]<imem_max+258*4)
memb[pila[sp-1]*4+pila[sp]]=memb[pila[mem[procs_s[num_proc].id+_param_offset]]*4];
else
memb[pila[sp-1]*4+pila[sp]]=(byte)pila[mem[procs_s[num_proc].id+_param_offset]];
}
sp-=2;
mem[procs_s[num_proc].id+_param_offset]++;
break;
/* OPERACIONES CON DATOS DE TIPO WORD */
case lptrwor:
pila[sp-1]=(unsigned int)memw[pila[sp-1]*2+pila[sp]];
sp--;
break;
case lasiwor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]=(word)pila[sp]);
sp-=2;
break;
case liptwor:
pila[sp-1]=(unsigned int)++memw[pila[sp-1]*2+pila[sp]];
sp--;
break;
case lptiwor:
utemp=pila[sp-1];
pila[sp-1]=(unsigned int)memw[utemp*2+pila[sp]]++;
sp--;
break;
case ldptwor:
pila[sp-1]=(unsigned int)--memw[pila[sp-1]*2+pila[sp]];
sp--;
break;
case lptdwor:
utemp=pila[sp-1];
pila[sp-1]=(unsigned int)memw[utemp*2+pila[sp]]--;
sp--;
break;
case ladawor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]+=(word)pila[sp]);
sp-=2;
break;
case lsuawor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]-=(word)pila[sp]);
sp-=2;
break;
case lmuawor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]*=(word)pila[sp]);
sp-=2;
break;
case ldiawor:
/* #ifdef DEBUG
if (pila[sp]==0) {
memw[pila[sp-2]*2+pila[sp-1]]=0;
sp-=2; pila[sp]=0;
v_function=-2; e(145);
if (call_to_debug) { process_stoped=id; return; }
break;
}
#endif*/
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]/=(word)pila[sp]);
sp-=2;
break;
case lmoawor:
/* #ifdef DEBUG
if (pila[sp]==0) {
memw[pila[sp-2]*2+pila[sp-1]]=0;
sp-=2; pila[sp]=0;
v_function=-2; e(145);
if (call_to_debug) { process_stoped=id; return; }
break;
}
#endif*/
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]%=(word)pila[sp]);
sp-=2;
break;
case lanawor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]&=(word)pila[sp]);
sp-=2;
break;
case lorawor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]|=(word)pila[sp]);
sp-=2;
break;
case lxoawor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]^=(word)pila[sp]);
sp-=2;
break;
case lsrawor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]>>=(word)pila[sp]);
sp-=2;
break;
case lslawor:
pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]<<=(word)pila[sp]);
sp-=2;
break;
case lcpawor:
_param_offset=reservedptr("param_offset");
if ((unsigned)pila[mem[procs_s[num_proc].id+_param_offset]]<256) {
memw[pila[sp-1]*2+pila[sp]]=(word)pila[mem[procs_s[num_proc].id+_param_offset]];
} else {
if (pila[mem[procs_s[num_proc].id+_param_offset]]<imem_max+258*4)
memw[pila[sp-1]*2+pila[sp]]=memw[pila[mem[procs_s[num_proc].id+_param_offset]]*2];
else
memw[pila[sp-1]*2+pila[sp]]=(word)pila[mem[procs_s[num_proc].id+_param_offset]];
} sp-=2; mem[procs_s[num_proc].id+_param_offset]++; break;
/* OPERACIONES CON DATOS DE TIPO STRING */
/* Nota: un puntero a cadena menor a 256 se trata siempre como "%c" */
case lstrcpy:
/* #ifdef DEBUG
if ((mem[pila[sp-1]-1]&0xFFF00000)!=0xDAD00000) {
sp--; v_function=-2; e(164);
if (call_to_debug) { process_stoped=id; return; }
break;
}
if ((unsigned)pila[sp]>255) if ((mem[pila[sp-1]-1]&0xFFFFF)+1<strlen((char*)&mem[pila[sp]])) {
sp--; v_function=-2; e(140);
if (call_to_debug) { process_stoped=id; return; }
break;
}
#endif*/
if ((unsigned)pila[sp]>255)
strcpy((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]]);
else
sprintf((char*)&mem[pila[sp-1]],"%c\0",pila[sp]);
sp--;
break;
case lstrfix:
if (pila[sp-1]>=(oo=strlen(&memb[pila[sp-2]*4]))) {
for (;oo<pila[sp-1];oo++) {
memb[pila[sp-2]*4+oo]=' ';
} memb[pila[sp-2]*4+oo+1]=0;
} break;
case lstrcat:
/* #ifdef DEBUG
if ((mem[pila[sp-1]-1]&0xFFF00000)!=0xDAD00000) {
sp--; v_function=-2; e(164);
if (call_to_debug) { process_stoped=id; return; }
break;
}
if ((unsigned)pila[sp]>255) oo=strlen((char*)&mem[pila[sp]]); else oo=1;
if ((mem[pila[sp-1]-1]&0xFFFFF)+1<strlen((char*)&mem[pila[sp-1]])+oo) {
sp--; v_function=-2; e(140);
if (call_to_debug) { process_stoped=id; return; }
break;
}
#endif*/
if ((unsigned)pila[sp]>255) strcat((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]]);
else sprintf((char*)&mem[pila[sp-1]],"%s%c\0",(char*)&mem[pila[sp-1]],pila[sp]);
sp--;
break;
case lstradd: /* Strcat "en el aire" (ojo, el aire tiene tambien 0xDAD00402) */
/* #ifdef DEBUG
if ((unsigned)pila[sp-1]>255) oo=strlen((char*)&mem[pila[sp-1]]); else oo=1;
if ((unsigned)pila[sp]>255) oo+=strlen((char*)&mem[pila[sp]]); else oo+=1;
if (oo>=1028) {
sp--; v_function=-2; e(140);
if (call_to_debug) { process_stoped=id; return; }
break;
}
#endif*/
if ((unsigned)pila[sp-1]>255) {
if ((unsigned)pila[sp]>255) {
sprintf((char*)&mem[nullstring[nstring]],"%s%s\0",(char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]]);
} else {
sprintf((char*)&mem[nullstring[nstring]],"%s%c\0",(char*)&mem[pila[sp-1]],pila[sp]);
}
} else {
if ((unsigned)pila[sp]>255) {
sprintf((char*)&mem[nullstring[nstring]],"%c%s\0",pila[sp-1],(char*)&mem[pila[sp]]);
} else {
sprintf((char*)&mem[nullstring[nstring]],"%c%c\0",pila[sp-1],pila[sp]);
}
}
pila[--sp]=nullstring[nstring];
nstring=((nstring+1)&3);
break;
case lstrdec: /* cambio de tamaño "en el aire" (no da error, hace lo que puede) */
oo=strlen((char*)&mem[pila[sp-1]]);
if (oo<1028) {
strcpy((char*)&mem[nullstring[nstring]],(char*)&mem[pila[sp-1]]);
if (pila[sp]>0) { /* Quitar caracteres */
if (pila[sp]>=oo) memb[nullstring[nstring]*4]=0;
else memb[nullstring[nstring]*4+oo-pila[sp]]=0;
} else if (pila[sp]<0) { /* Añadir (?) caracteres (por homogeneidad) */
pila[sp]=oo-pila[sp]; /* Nueva longitud */
if (pila[sp]>1025) pila[sp]=1025;
for (;oo<pila[sp];oo++) {
memb[nullstring[nstring]*4+oo]=' ';
} memb[nullstring[nstring]*4+oo]=0;
}
} else mem[nullstring[nstring]]=0;
pila[--sp]=nullstring[nstring];
nstring=((nstring+1)&3);
break;
case lstrsub: /* cambio de tamaño a un string */
oo=strlen((char*)&mem[pila[sp-1]]);
/* #ifdef DEBUG
if ((mem[pila[sp-1]-1]&0xFFF00000)!=0xDAD00000) {
sp--; v_function=-2; e(164);
if (call_to_debug) { process_stoped=id; return; }
break;
}
if ((mem[pila[sp-1]-1]&0xFFFFF)+1<oo-pila[sp]) {
sp--; v_function=-2; e(140);
if (call_to_debug) { process_stoped=id; return; }
break;
}
#endif*/
if (pila[sp]>0) { // Quitar caracteres
if (pila[sp]>=oo) memb[pila[sp-1]*4]=0;
else memb[pila[sp-1]*4+oo-pila[sp]]=0;
} else if (pila[sp]<0) { /* Añadir (?) caracteres (por homogeneidad) */
pila[sp]=oo-pila[sp]; /* Nueva longitud */
for (;oo<pila[sp];oo++) {
memb[pila[sp-1]*4+oo]=' ';
} memb[pila[sp-1]*4+oo]=0;
} sp--;
break;
case lstrlen:
if ((unsigned)pila[sp]>255) pila[sp]=strlen((char*)&mem[pila[sp]]); else pila[sp]=1;
break;
case lstrigu:
if ((unsigned)pila[sp-1]>255) {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])) pila[sp-1]=0; else pila[sp-1]=1;
} else {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])) pila[sp-1]=0; else pila[sp-1]=1;
}
} else {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])) pila[sp-1]=0; else pila[sp-1]=1;
} else {
pila[sp-1]=(pila[sp-1]==pila[sp]);
}
} sp--; break;
case lstrdis:
if ((unsigned)pila[sp-1]>255) {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])) pila[sp-1]=1; else pila[sp-1]=0;
} else {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])) pila[sp-1]=1; else pila[sp-1]=0;
}
} else {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])) pila[sp-1]=1; else pila[sp-1]=0;
} else {
pila[sp-1]=(pila[sp-1]!=pila[sp]);
}
} sp--; break;
break;
case lstrmay:
if ((unsigned)pila[sp-1]>255) {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])>0) pila[sp-1]=1; else pila[sp-1]=0;
} else {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])>0) pila[sp-1]=1; else pila[sp-1]=0;
}
} else {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])>0) pila[sp-1]=1; else pila[sp-1]=0;
} else {
pila[sp-1]=(pila[sp-1]>pila[sp]);
}
} sp--; break;
break;
case lstrmen:
if ((unsigned)pila[sp-1]>255) {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])<0) pila[sp-1]=1; else pila[sp-1]=0;
} else {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])<0) pila[sp-1]=1; else pila[sp-1]=0;
}
} else {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])<0) pila[sp-1]=1; else pila[sp-1]=0;
} else {
pila[sp-1]=(pila[sp-1]<pila[sp]);
}
} sp--; break;
break;
case lstrmei:
if ((unsigned)pila[sp-1]>255) {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])<=0) pila[sp-1]=1; else pila[sp-1]=0;
} else {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])<=0) pila[sp-1]=1; else pila[sp-1]=0;
}
} else {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])<=0) pila[sp-1]=1; else pila[sp-1]=0;
} else {
pila[sp-1]=(pila[sp-1]<=pila[sp]);
}
} sp--; break;
break;
case lstrmai:
if ((unsigned)pila[sp-1]>255) {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])>=0) pila[sp-1]=1; else pila[sp-1]=0;
} else {
if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])>=0) pila[sp-1]=1; else pila[sp-1]=0;
}
} else {
if ((unsigned)pila[sp]>255) {
if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])>=0) pila[sp-1]=1; else pila[sp-1]=0;
} else {
pila[sp-1]=(pila[sp-1]>=pila[sp]);
}
} sp--; break;
break;
case lcpastr:
_param_offset=reservedptr("param_offset");
/* #ifdef DEBUG
if ((mem[pila[sp]-1]&0xFFF00000)!=0xDAD00000) {
sp--; mem[id+_Param]++; v_function=-2; e(164);
if (call_to_debug) { process_stoped=id; return; }
break;
}
if ((unsigned)pila[mem[id+_Param]]>255) {
if ((mem[pila[sp]-1]&0xFFFFF)+1<strlen((char*)&mem[pila[mem[id+_Param]]])) {
sp--; mem[id+_Param]++; v_function=-2; e(140);
if (call_to_debug) { process_stoped=id; return; }
break;
}
}
#endif*/
if ((unsigned)pila[mem[procs_s[num_proc].id+_param_offset]]>255)
strcpy((char*)&mem[pila[sp]],(char*)&mem[pila[mem[procs_s[num_proc].id+_param_offset]]]);
else sprintf((char*)&mem[pila[sp]],"%c\0",pila[mem[procs_s[num_proc].id+_param_offset]]);
sp--; mem[procs_s[num_proc].id+_param_offset]++;
break;
/* Comprobación de punteros nulos */
case lnul:
/* #ifdef DEBUG
if (!pila[sp]) {
v_function=-2; e(165);
if (call_to_debug) { process_stoped=id; return; }
}
#endif*/
break;
/* OPCODES NUEVOS DE EDIV */
case lextasp:
externa=extfuncs[mem[imem]];
// corresponder con FUNCTION_PARAMS
//temp = externa(pila,&sp,mem,varindex,&procs_s,Call_Entrypoint);
fp.num_params=extparms[mem[imem++]];
externa(&fp);
break;
}
#ifdef DBG
Call_Entrypoint(EDIV_trace,imem,nombre_program,lin,0);
#ifdef _DEBUG
actual_lin=localiza_lin(imem);
if(actual_lin!=last_lin) {
unsigned char* p=&prog[lin[actual_lin*4+3]];
// printf("[%d|%d-%d] ",imem,lin[actual_lin*4+3],lin[actual_lin*4+4]);
printf("[%d] ",imem);
while(p<=&prog[lin[actual_lin*4+4]]) {
putc(*p,stdout);
p++;
}
printf("\n");
last_lin=actual_lin;
}
#endif /* _DEBUG */
#endif /* DBG */
}
if ( devolver > 0 && no_devuelve == 0 )
{
//pila[++sp] = 0 ;// AQUI SE DEBERA DEVOLVER EL ID
pila[++sp]=procs_s[num_proc].id;
devolver-- ;
}
Call_Entrypoint(EDIV_post_process);
return 1 ;
}
void aplicar_waves (int tiempo, int cant_iteraciones, const char *nomb_impl, const char *nomb_arch_entrada, float x_scale, float y_scale, float g_scale) {
IplImage *src = 0;
IplImage *dst = 0;
CvSize dst_size;
// Cargo la imagen
if( (src = cvLoadImage (nomb_arch_entrada, CV_LOAD_IMAGE_GRAYSCALE)) == 0 )
exit(EXIT_FAILURE);
dst_size.width = src->width;
dst_size.height = src->height;
// Creo una IplImage para cada salida esperada
if( (dst = cvCreateImage (dst_size, IPL_DEPTH_8U, 1) ) == 0 )
exit(EXIT_FAILURE);
// Chequeo de parametros
if (!(x_scale <= 32.0 && x_scale >= 0.0 &&
y_scale <= 32.0 && y_scale >= 0.0 &&
g_scale <= 255.0 && g_scale >= 0.0)) {
imprimir_ayuda();
cvReleaseImage(&src);
cvReleaseImage(&dst);
exit ( EXIT_SUCCESS );
}
typedef void (waves_fn_t) (unsigned char*, unsigned char*, int, int, int, float, float, float);
waves_fn_t *proceso;
if (strcmp(nomb_impl, "c") == 0) {
proceso = waves_c;
} else {
proceso = waves_asm;
}
if (tiempo) {
unsigned long long int start, end;
MEDIR_TIEMPO_START(start);
for(int i=0; i<cant_iteraciones; i++) {
proceso((unsigned char*)src->imageData, (unsigned char*)dst->imageData, src->height, src->width, src->widthStep, x_scale, y_scale, g_scale);
}
MEDIR_TIEMPO_STOP(end);
imprimir_tiempos_ejecucion(start, end, cant_iteraciones);
} else {
proceso((unsigned char*)src->imageData, (unsigned char*)dst->imageData, src->height, src->width, src->widthStep, x_scale, y_scale, g_scale);
}
// Guardo imagen y libero las imagenes
char nomb_arch_salida[256];
memset(nomb_arch_salida, 0, 256);
sprintf(nomb_arch_salida, "%s.waves.x_scale-%3.2f.y_scale-%3.2f.g_scale-%3.2f.%s.bmp", nomb_arch_entrada, x_scale, y_scale, g_scale, nomb_impl);
cvSaveImage(nomb_arch_salida, dst, NULL);
cvReleaseImage(&src);
cvReleaseImage(&dst);
}
void aplicar_umbralizar (int tiempo, int cant_iteraciones, const char *nomb_impl, const char *nomb_arch_entrada, unsigned char min, unsigned char max, unsigned char q) {
IplImage *src = 0;
IplImage *dst = 0;
CvSize dst_size;
// Cargo la imagen
if( (src = cvLoadImage (nomb_arch_entrada, CV_LOAD_IMAGE_GRAYSCALE)) == 0 )
exit(EXIT_FAILURE);
dst_size.width = src->width;
dst_size.height = src->height;
// Creo una IplImage para cada salida esperada
if( (dst = cvCreateImage (dst_size, IPL_DEPTH_8U, 1) ) == 0 )
exit(EXIT_FAILURE);
// Chequeo de parametros
if (!(min <= max && min >= 0 && max <= 255 && q >= 0 && q <= 255)) {
imprimir_ayuda();
cvReleaseImage(&src);
cvReleaseImage(&dst);
exit ( EXIT_SUCCESS );
}
typedef void (umbralizar_fn_t) (unsigned char*, unsigned char*, int, int, int, unsigned char, unsigned char, unsigned char);
umbralizar_fn_t *proceso;
if (strcmp(nomb_impl, "c") == 0) {
proceso = umbralizar_c;
} else {
proceso = umbralizar_asm;
}
if (tiempo) {
unsigned long long int start, end;
MEDIR_TIEMPO_START(start);
for(int i=0; i<cant_iteraciones; i++) {
proceso((unsigned char*)src->imageData, (unsigned char*)dst->imageData, src->height, src->width, src->widthStep, min, max, q);
}
MEDIR_TIEMPO_STOP(end);
imprimir_tiempos_ejecucion(start, end, cant_iteraciones);
} else {
proceso((unsigned char*)src->imageData, (unsigned char*)dst->imageData, src->height, src->width, src->widthStep, min, max, q);
}
// Guardo imagen y libero las imagenes
char nomb_arch_salida[256];
memset(nomb_arch_salida, 0, 256);
sprintf(nomb_arch_salida, "%s.umbralizar.min-%d.max-%d.q-%d.%s.bmp", nomb_arch_entrada, min, max, q, nomb_impl);
cvSaveImage(nomb_arch_salida, dst, NULL);
cvReleaseImage(&src);
cvReleaseImage(&dst);
}
//---------------------------------------------------------------------------
void __fastcall ProcesoThresholdingColorNegro::Execute()
{
TotalArchivos=0;
TotalArchivos=picture->GetTotalRecords();
if(TotalArchivos<=0){return;} /* si no se ha seleccionado ningún archivo se
se termina el proceso */
/* se crea directorio de reporte */
AnsiString DirReport=ExtractFileDir(AnsiString(picture->FileName[0]))+"\\result";
CreateDir(DirReport);
/* se crea archivo resumen */
AnsiString ArchivoResumen=DirReport+"\\resumen.txt";
FILE *streamRes;
streamRes = fopen (ArchivoResumen.c_str(),"w");
if(streamRes==NULL){fclose(streamRes);}
else
{
fprintf(streamRes,"%s\n", " Total Total ");
fprintf(streamRes,"%s\n\n"," Pixels cm2 File name");
fclose(streamRes);
}
/* Progress Bar */
Synchronize(definirMaxDeProgressBar);
/* SE INICIA EL PROCESO */
iReg=0;
for(iReg=0;iReg<TotalArchivos;iReg++)
{
// se ubica el archivo en el sgLista
Synchronize(ubicarReg_en_sglista);
// se forma el nombre del archivo bitmap salida
archivoOrig=picture->FileName[iReg];
AnsiString archivoX=ExtractFileName(picture->FileName[iReg]);
archivoBitmapTH="";
for(int z=1;z<=archivoX.Length()-4;z++)
{
archivoBitmapTH=archivoBitmapTH+archivoX[z];
}
archivoBitmapTH=archivoBitmapTH+"_Thr";
archivoBitmapTH=DirReport+"\\"+archivoBitmapTH+".bmp";
// cargo la imagen
try
{
archivoBMP=picture->FileName[iReg];
proceso(archivoBitmapTH,ArchivoResumen,0,picture->Width[iReg],0,picture->Height[iReg],iReg);
// Synchronize(GuardarTH);
}
catch(...)
{
picture->Height[iReg]=0;
picture->Width[iReg]=0;
picture->TotalPixel[iReg]=0;
picture->LAI[iReg]=0.0;
picture->TimeDuration[iReg]=0;
}
Synchronize(mostrarInfo_en_sglista);
Synchronize(avanzarProgressBar);
}
/* FINALIZA EL PROCESO */
Synchronize(ubicarRegInicial_en_sglista);
Synchronize(msgFinal);
}
