/**
* Read the next line from a file.
* The returned string must be freed by the invoker.
*/
char* reader_get_line() {
int length = ReaderLineLengthInit;
int position = 0;
char *line = (char*)malloc(length);
if (!line)
error_fatal(ErrorMemoryAlloc);
do {
line[position++] = getc(reader_file);
/* If the position is divisible by the initial size, then more space is
* needed for the line. */
if(!(position % ReaderLineLengthInit)) {
/* Increase the line length by the initial size. */
length += ReaderLineLengthInit;
line = (char*)realloc(line, length);
if (!line)
error_fatal(ErrorMemoryAlloc);
}
} while (line[position - 1] != '\n' && line[position - 1] != EOF);
if (line[0] == EOF) {
free(line);
return NULL;
}
line[position - 1] = '\0';
return line;
}
static void process_header(seq_t *seq, char *header) {
char *id, *comm, *p, *q;
int i, n, l;
n = 0;
p = header;
/* skip > */
p++;
while(*p && isascii((int)*p) && !isspace((int)*p)) {
p++; n++;
}
/* check if sequence is named or not */
if (n == 1 && strchr( ".,;", (int)header[1])) n = 0;
l = ( n == 0) ? 9 : n;
if((id = malloc(sizeof(char)*(l+1))) == NULL){
error_fatal("memory", NULL);
}
p = header;
p++;
/* check if sequence is named or not */
if ( n == 0 ){
error_warn("anonymous sequence",
"name will be forced to \"anonymous\"");
snprintf(id,10, "anonymous");
}
else {
q = id;
for (i=0; i<n; i++) {
/* replace all non alnum character by '_' */
if (isalnum((int)*p)) *q++ = *p++;
else { *q++ = '_'; p++; }
}
*q = '\0';
}
/* skip spaces */
while(*p && (isspace((int)*p))) { p++; n++; }
/* get comment */
if((comm = malloc(sizeof(char) * (strlen(header) - n))) == NULL){
error_fatal("memory", "COMLEN");
}
q = comm;
while(*p && *p != '\n') { *q++ = *p++; }
*q = '\0';
seq->id = id;
seq->comment = comm;
}
/*************************** info_digitalizador *****************************
Función para solicitar información al digitalizador sobre los valores
máximos y mínimos de los parámetros modificables del digitalizador, y
comprobar que los valores que se desean fijar para la adquisición de
imágenes está dentro de los valores permitidos.
*****************************************************************************/
int info_digitalizador(MIL_ID digitalizador)
{
char t[LONGITUD_TEXTO];
MdigInquire(digitalizador, M_BRIGHTNESS + M_MAX_VALUE, &limCam.MaxBrillo);
MdigInquire(digitalizador, M_BRIGHTNESS + M_MIN_VALUE, &limCam.MinBrillo);
if (paramAux->Cam.brillo < limCam.MinBrillo || paramAux->Cam.brillo > limCam.MaxBrillo) {
sprintf(t, "Valor del parámetro de brillo inaceptable: [%5d, %5d] = %d",
limCam.MinBrillo, limCam.MaxBrillo, paramAux->Cam.brillo);
error_fatal("info_digitalizador", t, 0);
Sleep(1000);
return 1;
}
MdigInquire(digitalizador, M_GAIN+M_MAX_VALUE, &limCam.MaxGanancia);
MdigInquire(digitalizador, M_GAIN+M_MIN_VALUE, &limCam.MinGanancia);
if (paramAux->Cam.ganancia < limCam.MinGanancia || paramAux->Cam.ganancia > limCam.MaxGanancia) {
sprintf(t, "Valor del parámetro de ganancia inaceptable: [%5d, %5d] = %d",
limCam.MinGanancia, limCam.MaxGanancia, paramAux->Cam.ganancia);
error_fatal("info_digitalizador", t, 0);
Sleep(1000);
return 1;
}
MdigInquire(digitalizador, M_SHUTTER+M_MAX_VALUE, &limCam.MaxExposicion);
MdigInquire(digitalizador, M_SHUTTER+M_MIN_VALUE, &limCam.MinExposicion);
GetLimitesBaseExposicion(limCam.MinBaseExposicion,limCam.MaxBaseExposicion);
//Debemos comprobar si es correcta la exposicion en todos los filtros
for (int i=0; i<MAX_FILTROS_DTA;i++)
{
if (paramAux->Rueda.exposicion[i] < limCam.MinExposicion || paramAux->Rueda.exposicion[i] > limCam.MaxExposicion) {
sprintf(t, "Valor del parámetro de exposicion para la banda %d inaceptable: [%5d, %5d] = %d",
i,limCam.MinExposicion, limCam.MaxExposicion, paramAux->Rueda.exposicion[i]);
error_fatal("info_digitalizador", t, 0);
Sleep(1000);
return 1;
}
if (paramAux->Rueda.base_exp[i] < limCam.MinBaseExposicion || paramAux->Rueda.base_exp[i] > limCam.MaxBaseExposicion) {
sprintf(t, "Valor del parámetro de base de exposicion para la banda %d inaceptable: [%5d, %5d] = %d",
i,limCam.MinExposicion, limCam.MaxExposicion, paramAux->Rueda.base_exp[i]);
error_fatal("info_digitalizador", t, 0);
Sleep(1000);
return 1;
}
}
return 0;
}
int main(int argc, char *argv[])
{
int sock, sock_listen, sock_acept, length, fromlen, n;
struct sockaddr_in server;
struct sockaddr_in from;
char buffer[TAMANO];
/* creacion del socket del servidor*/
sock=socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
error_fatal("Creando el socket");
length = sizeof(server);
memset(&server,0,length); /*limpio la direccion del socket del servidor*/
/* vinculo la direccion IP y puerto local al socket creado anteriormente */
server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=htons(atoi(argv[1]));
if (bind(sock,(struct sockaddr *)&server,length)<0)
error_fatal("binding");
/* se avisa al sistema que comience a atender llamadas de clientes*/
sock_listen = listen (sock, 1);
if (sock_listen == -1)
error_fatal("listen");
fromlen = sizeof(struct sockaddr_in);
sock_acept = accept(sock, (struct sockaddr *) &from, &fromlen);
if (sock_acept == -1)
error_fatal("accept");
/* bucle principal. Pongo a recibir y responder mensajes a traves del socket*/
while (1) {
n = recv(sock_acept, buffer, sizeof(buffer), 0);
/* datagrama recibido*/
buffer[n]='\0'; /* para poder imprimirlo con prinft*/
printf("%s\n", buffer+4);
/*enviar respuesta*/
memset(buffer,0,strlen(buffer)); /*limpio el buffer*/
}
}
/*
keep that for compatibility with old export python.
*/
result_t * access_search_deprecated(char *dbase, char *name) {
result_t * res;
// result_t * adr_res=&res;
int nb_AC_not_found=1;
if ((res=malloc(sizeof(result_t)))==NULL) error_fatal("memory", NULL);
res->name=strdup(name);
res->dbase=strdup(dbase);
res->filenb=NOT_FOUND;
WDBQueryData wData;
wData.len_l=1;
wData.start_l=&res;
access_search(wData,dbase,&nb_AC_not_found);
#ifdef DEBUG
if (res->filenb!=NOT_FOUND) {
printf("access_search_deprecated, found : \n");
printf("%s:%s\n,real_dbase; %s\n, filenb=%d\n, offset=%lld\n",res->dbase,res->name,res->real_dbase,res->filenb,res->offset);
} else {
printf("access_search_deprecated, didn't find : %s:%s \n",res->dbase,res->name);
}
#endif
return res;}
char *alphabet_maker (char *alphabet) {
char *res, *p;
int j;
if ((res = calloc(255, sizeof(char))) == NULL) {
error_fatal("memory", NULL);
}
p = alphabet;
while(*p) {
j = (int)*p;
if ( islower(j) ){
res[j] = toupper((int)*p);
res[j-32] = toupper((int)*p);
}
else{
res[j] = *p;
res[j+32] = *p;
}
p++;
}
return res;
}
/************************** graba_imagen_campo ****************************
Función para efectuar la grabación en disco de una imagen del campo.
"nombre" es el nombre del archivo a almacenar.
"buffer" es el buffer que quiero copiar a disco.
****************************************************************************/
int graba_imagen_campo(char *nombre, MIL_ID buffer, int nBits, double dEscala)
{
char nombre_ext[1024], *ext, mensaje[1024], *fn = "graba_imagen_campo";
strcpy(nombre_ext, nombre); // Se copia en nombre_ext el nombre de la imagen a cargar
ext = strrchr(nombre_ext, '.'); // Se busca la extensión del fichero que se desea guardar
strcpy(nombre_ext, ext+1);
// Copiamos el buffer seleccionado en el archivo seleccionado (nombre_ext).
if ( strcmp(nombre_ext,"jpg")==0 ) MbufExport(nombre, M_JPEG_LOSSLESS, buffer);
if ( strcmp(nombre_ext,"tif")==0 )
{
MbufExport(nombre, M_TIFF, buffer);
if (nBits >0 && dEscala > 0)
INTERFAZ_LIBTIF::EscribirTags(nombre, nBits, dEscala);
else if (dEscala > 0)
INTERFAZ_LIBTIF::EscribirTags(nombre, 0, dEscala);
else if (nBits > 0)
INTERFAZ_LIBTIF::EscribirTags(nombre, nBits, 0);
else
INTERFAZ_LIBTIF::EscribirTags(nombre, 0, 0);
}
if ( strcmp(nombre_ext,"mim")==0 ) MbufExport(nombre, M_MIL, buffer);
/* Compruebo que no ha habido ningún error durante el proceso de grabación a disco. */
if ( MbufDiskInquire(nombre, M_SIZE_X, M_NULL) == 0) {
sprintf(mensaje, "No puedo crear la imagen %s", nombre_ext);
error_fatal(fn, mensaje, 0);
return 1;
}
return 0;
}
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
// char *raiz_paramIni; // raiz del directorio del fichero inicial
int nRetCode = 0;
int i, c;
int aplicaLutColor = 0;
char mensaje[512], nombre_ext[512];
FILE *fich;
int nCampo = 0;
char nombreToma[MAX_NOMBRE_TOMA] = "Toma"; //Para pedir el nombre de la toma y guardar las imagenes
char directorioToma[512] = ""; //Directorio que crearemos para las imagenes de las tomas
CCorreccionGeometrica correccionGeometrica;
// Procesamos los argumentos de la línea de comandos
procesa_argumentos(argc, argv,directorioToma);
/*
raiz_paramIni = procesa_argumentos(argc, argv,directorioToma);
if ( raiz_paramIni==NULL || directorioToma == "")
{
return (nRetCode = 1);
}
strcpy(paramIni.raiz_patrones,raiz_paramIni);
*/
// Compongo el nombre de log de la aplicación
sprintf(fichLog, "TomaUnica%s",EXT_LOG);
if ( (fich = fopen(fichLog, "wt")) == NULL ) {
sprintf(mensaje, "NO se puede crear el fichero: %s", fichLog);
error_fatal("TomaUnica.exe", mensaje, 0);
goto final;
}
/* VL: keep db_name parameter for recursive calls when searching in virtual database indexes.
* lst_notFound points to a memory area allocated by the caller to store adresses of result_t structures for which no match was found.
* It is used and "free" by the caller.
* For recursive calls to access_search and calls to index_search, use memory areas allocated by access_search.
*/
void access_search(WDBQueryData wData, char * db_name, int * nb_AC_not_found) {
FILE *f;
char *p, *file, buf[1024];
int nb_AC_found;
#ifdef DEBUG
result_t ** start_l=wData.start_l; // for printing debug info
#endif
// cur_base may be virtual.
/* Virtual database indexes */
file = index_file(NULL, db_name, VIRSUF);
//printf("Searching in file : %s \n",file);
if (access(file, F_OK) != -1) {
if ((f = fopen(file, "r")) == NULL) {
error_fatal("memory", NULL); }
while (fgets(buf, 1023, f) != NULL) {
if ((p = strrchr(buf, '\n')) != NULL) { *p = '\0'; }
access_search(wData, buf, nb_AC_not_found);
#ifdef DEBUG
// dump list of accession numbers that were not found yet.
print_wrk_struct(start_l,wData.len_l,1);
#endif
if (*nb_AC_not_found!=0) {
#ifdef DEBUG
printf("access_search : all results were not found ; continue \n");
#endif
continue;
}
break;
}
if (fclose(f) == EOF) {
error_fatal("memory", NULL); }
free(file);
return; }
/* Real database indexes */
file = index_file(NULL, db_name, ACCSUF);
#ifdef DEBUG
printf("Searching in file : %s \n",file);
#endif
nb_AC_found=index_search(file, db_name, wData, nb_AC_not_found);
#ifdef DEBUG
printf("access_search : returned from index_search DB : %s : nb_not_found_for_db=%d, nb_res_found=%d \n",db_name,*nb_AC_not_found,nb_AC_found);
#endif
free(file);
return; }
//---------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------
IEditorEntityFactory::IEditorEntityFactory( const char *type )
{
std::string sType(type);
auto list = GetList();
if( list.find(sType) != list.end() )
error_fatal( "Type %s is already there, have a look into your Factory Registrations!!" );
GetList()[sType] = this;
}
void doublearray_resize(doublearray_t array, unsigned n_values) {
for (unsigned i = 0; array[i] != NULL; i++) {
array[i] = realloc(array[i], sizeof(double) * n_values);
if (array[i] == NULL) {
error_fatal("Failed to allocate more memory for dobule array");
}
}
}
int machine_gen_code (Machine *m, int op){
assert(m != NULL) ;
//assert(op >= add && op <= sub) ;
if (m->IP == SEGMENT_CODE_SIZE)
error_fatal("Segment de code plein") ;
m->segment_code[m->IP] = op ;
m->IP++ ;
return 0 ;
}
/* Check aligment file format */
alifmt_t align_format(FILE *f) {
int i;
off_t off;
alifmt_t fmt;
if ((off = ftello(f)) == -1) {
error_fatal("file position", NULL); }
for (fmt = ALIFMT_UNKWN + 1; fmt != ALIFMT_NONE; fmt++) {
i = align_check(f, fmt);
if (fseeko(f, off, SEEK_SET) != 0) {
error_fatal("file position", NULL); }
if (i == 0) { break; }
}
return fmt; }
static int puissance (int v1, int v2){
if (v1 == 0 && v2 == 0)
error_fatal("elévation à la puissance") ;
long res = v1 ;
while (v2--)
res *= v1 ;
if (res > INT_MAX)
warning("Pw debordement de capacité");
return (int) res ;
}
char* reader_get_file_name(const char* extension) {
char* file_name;
unsigned int full_length, base_length = strlen(reader_file_name_base);
full_length = base_length + strlen(extension) + 1;
file_name = (char*)malloc(full_length);
if (!file_name)
error_fatal(ErrorMemoryAlloc);
strcpy(file_name, reader_file_name_base);
/* Add the file extension. */
file_name[base_length] = '.';
strcpy(file_name + base_length + 1, extension);
file_name[full_length] = '\0';
return file_name;
}
int machine_gen_chaine (Machine *m, const char *chaine) {
assert(m != NULL) ;
assert(chaine != NULL);
if (m->IP == SEGMENT_CODE_SIZE)
error_fatal("Segment de code plein") ;
m->segment_code[m->IP++] = outc ;
while (*chaine) {
m->segment_code[m->IP++] = *chaine ;
chaine++ ;
}
m->segment_code[m->IP++] = *chaine ;
return 0 ;
}
/**
* Open a file for reading.
* Store the file pointer in the reader's global variable.
*/
void reader_open_file(const char* file_name) {
char* full_file_name;
/* Create a string with the file name and extension. */
/* Store the file name for error reporting and for creating output files. */
reader_file_name_base = (char*)malloc(strlen(file_name) + 1);
if (!reader_file_name_base)
error_fatal(ErrorMemoryAlloc);
strcpy(reader_file_name_base, file_name);
full_file_name = reader_get_file_name(ReaderFileExtension);
/* Open the file. */
reader_file = fopen(full_file_name, "r");
if (!reader_file) {
fprintf(stderr, ErrorCantRead, full_file_name);
fprintf(stderr, "\n");
free(full_file_name);
exit(EXIT_FAILURE);
}
free(full_file_name);
}
symbol_handle symbol_lookup() {
string_done();
symbol_handle place = _symbol_hash;
for (;;) {
if (_symbol_table[place] == STRING_NULL) {
// add symbol to table
_symbol_table[place] = _symbol_string;
string_accept();
return place;
}
if (!string_eq(_symbol_table[place], _symbol_string)) {
// symbol is already in the table
string_reject();
return place;
}
place += 1;
if (place == SYMBOL_SIZE) place = 0;
if (place == _symbol_hash) error_fatal(ER_HASHFULL, "Symbol table");
}
}
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
char nombre_aplicacion[20] = "TomaPatron.exe";
char *tipo_patron = NULL; // Tipo de patron: claro(CL); oscuro(OS) que se desea adquirir.
int nRetCode = 0;
// variable que indica la necesidad de ajustar automaticamente las exposiciones justo antes de comenzar el barrido del patron (en caso de que no se haya hecho manualmente antes)
bool bExposicionAjustada = false;
int i, c;
char mensaje[512], nombre_ext[512];
FILE *fich;
// Procesamos los argumentos de la línea de comandos
// if (procesa_argumentos(argc, argv, paramIni.raiz_patrones, &tipo_patron)==0 ) return (nRetCode = 1);
// Compongo el nombre de log de la aplicación
sprintf(fichLog, "TomaPatron%s", EXT_LOG);
if ( (fich = fopen(fichLog, "wt")) == NULL ) {
sprintf(mensaje, "NO se puede crear el fichero: %s", fichLog);
error_fatal(nombre_aplicacion, mensaje, 0);
goto final;
}
int begin(char* base_file_name, unsigned char *png_buf, long long png_length) {
MY_PNG_READ_OFFSET = 0;
PNG_LENGTH = png_length;
ENTIRE_PNG_BUF = png_buf;
if (png_sig_cmp(ENTIRE_PNG_BUF, 0, 8) != 0) {
error(-1, "png_sig_cmp", E_INVALID);
return -1;
}
DEBUG_PRINT(("Initial png size is %lld bytes\n", PNG_LENGTH));
my_png_meta *pm = calloc(1, sizeof(my_png_meta));
my_init_libpng(pm);
//If libpng errors, we end up here
if (setjmp(png_jmpbuf(pm->read_ptr))) {
DEBUG_PRINT(("libpng called setjmp!\n"));
my_deinit_libpng(pm);
free(ENTIRE_PNG_BUF);
error(-1, "libpng", "libpng encountered an error\n");
return -1;
}
//Normally a file, but instead make it our buffer
void *read_io_ptr = png_get_io_ptr(pm->read_ptr);
png_set_read_fn(pm->read_ptr, read_io_ptr, my_png_read_fn);
//Transform all PNG image types to RGB
int transforms =
PNG_TRANSFORM_GRAY_TO_RGB |
PNG_TRANSFORM_STRIP_ALPHA |
PNG_TRANSFORM_EXPAND;
png_read_png(pm->read_ptr, pm->info_ptr, transforms, NULL);
//Now that it was read and transformed, its size will differ
PNG_LENGTH = 0;
//Lets collect our metadata
struct ihdr_infos_s ihdr_infos;
ihdr_infos.bit_depth = png_get_bit_depth(pm->read_ptr, pm->info_ptr);
ihdr_infos.color_type = png_get_color_type(pm->read_ptr, pm->info_ptr);
ihdr_infos.filter_method = png_get_filter_type(pm->read_ptr, pm->info_ptr);
ihdr_infos.compression_type = png_get_compression_type(pm->read_ptr, pm->info_ptr);
ihdr_infos.interlace_type = png_get_interlace_type(pm->read_ptr, pm->info_ptr);
ihdr_infos.height = png_get_image_height(pm->read_ptr, pm->info_ptr);
ihdr_infos.width = png_get_image_width(pm->read_ptr, pm->info_ptr);
if (ihdr_infos.color_type != 2) {
DEBUG_PRINT((E_INVALID));
free(ENTIRE_PNG_BUF);
my_deinit_libpng(pm);
DEBUG_PRINT(("Looks like libpng could not correctly convert to RGB\n"));
return -1;
}
//Just in case we want to enable alpha, etc
switch(ihdr_infos.color_type) {
case 0: //greyscale
case 3: //indexed
ihdr_infos.bytes_per_pixel = 1;
break;
case 4: ihdr_infos.bytes_per_pixel = 2; break; //greyscale w/ alpha
case 2: ihdr_infos.bytes_per_pixel = 3; break; //Truecolour (RGB)
case 6: ihdr_infos.bytes_per_pixel = 4; break; //Truecolour w/ alpha
default: error_fatal(1, "ihdr_infos", "Unknown image type"); //should never happen
}
ihdr_infos.scanline_len = (ihdr_infos.bytes_per_pixel * ihdr_infos.width) + 1;
DEBUG_PRINT(("HEIGHT: %u\n", ihdr_infos.height));
DEBUG_PRINT(("WIDTH: %u\n", ihdr_infos.width));
DEBUG_PRINT(("BIT_DEPTH: %u\n", ihdr_infos.bit_depth));
// Don't compress, since we are merely copying it to memory,
// we will be decompressing it again anyway
png_set_compression_level(pm->write_ptr, Z_NO_COMPRESSION);
void *write_io_ptr = png_get_io_ptr(pm->write_ptr);
png_set_write_fn(pm->write_ptr, write_io_ptr, my_png_write_fn, my_png_dummy_flush);
//Make sure we use all filters
png_set_filter(pm->write_ptr, 0,
PNG_FILTER_NONE | PNG_FILTER_VALUE_NONE |
PNG_FILTER_SUB | PNG_FILTER_VALUE_SUB |
PNG_FILTER_UP | PNG_FILTER_VALUE_UP |
PNG_FILTER_AVG | PNG_FILTER_VALUE_AVG |
PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH);
//Set our comment
struct png_text_struct comment_struct;
comment_struct.compression = -1;
comment_struct.key = " Glitched by pnglitch.xyz ";
comment_struct.text = NULL;
comment_struct.text_length = 0;
png_set_text(pm->write_ptr, pm->info_ptr, &comment_struct, 1);
//Buffer is Written using callback my_png_write_fn to buffer
//ENTIRE_PNG_BUF. PNG_LENGTH will be updated automatically by it
png_write_png(pm->write_ptr, pm->info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
my_deinit_libpng(pm);
DEBUG_PRINT(("libpng output buf is %lld bytes\n", PNG_LENGTH));
//Now that libpng has converted the image
//and we have it in a buffer, we process it by hand with zlib
struct z_stream_s inflate_stream;
my_init_zlib(&inflate_stream);
inflateInit(&inflate_stream);
//Pointer to keep track of where we are
unsigned char *pngp = ENTIRE_PNG_BUF;
//Skip PNG Signature
pngp += 8;
//Get Header
unsigned char ihdr_bytes_buf[4+4+13+4]; // size + label + content + crc
buf_read(ihdr_bytes_buf, &pngp, 4+4+13+4);
//When we run into non-idat chunks, we will want to preserve them.
//The spec says there's no chunk that needs to go after IDAT,
//so we can simply concatenate all of these chunks into a buffer
//then write them all at once after the IHDR
//ancillary chunks, eg comments
unsigned char *ancil_chunks_buf = calloc(1,1);
long long ancil_chunks_len = 0;
unsigned char *unzip_idats_buf = calloc(1, 1);
long unzip_buf_len = 1;
long unzip_buf_offset = 0;
long long zipped_idats_len = 0; //Length of all idats as we read them
unsigned long accum_png_len = 8 + (4+4+13+4);
int chunk_count = 0;
printf("Uncompressing image data...\n");
while (1) {
unsigned char chunk_label[4];
unsigned char chunk_len_buf[4];
buf_read(chunk_len_buf, &pngp, 4);
//first 4 bytes are the length of data section
long chunk_len = four_bytes_to_int(chunk_len_buf);
accum_png_len += chunk_len + 4 + 4 + 4; // plus len, crc, label
DEBUG_PRINT(("at %lu --> %lld\n", accum_png_len, PNG_LENGTH));
//leave at end of buffer
if (accum_png_len >= PNG_LENGTH)
break;
//read the chunk label (name of this header)
buf_read(chunk_label, &pngp, 4);
DEBUG_PRINT(("Reading chunk %d with label '%c%c%c%c', size %ld\n",
chunk_count, chunk_label[0], chunk_label[1], chunk_label[2],
chunk_label[3], chunk_len));
chunk_count += 1;
if (memcmp(chunk_label, "IDAT", 4) == 0) {
zipped_idats_len += chunk_len;
//read the chunk's data section
unsigned char *raw_chunk_buf = calloc(chunk_len, 1);
buf_read(raw_chunk_buf, &pngp, chunk_len);
//Tell inflate to uncompress it
inflate_stream.next_in = raw_chunk_buf;
inflate_stream.avail_in = chunk_len;
//Now uncompress it (resizes buffer automatically)
unsigned char *check_uncompress = uncompress_buffer(&inflate_stream,
unzip_idats_buf, &unzip_buf_len, &unzip_buf_offset);
//Stop if error
if (check_uncompress == NULL) {
DEBUG_PRINT((E_GLITCH));
free(ancil_chunks_buf);
free(raw_chunk_buf);
free(unzip_idats_buf);
free(ENTIRE_PNG_BUF);
return -1;
}
//Moving on
unzip_idats_buf = check_uncompress;
free(raw_chunk_buf);
pngp += 4; // skip CRC
} else { //This is not an idat
ancil_chunks_buf = realloc(ancil_chunks_buf,
ancil_chunks_len + 4 + 4 + chunk_len + 4); //make room for new data
//append length and label bytes
append_bytes(ancil_chunks_buf, chunk_len_buf, &ancil_chunks_len, 4);
append_bytes(ancil_chunks_buf, chunk_label, &ancil_chunks_len, 4);
//append chunk data
unsigned char *raw_chunk_buf = calloc(chunk_len, 1);
buf_read(raw_chunk_buf, &pngp, chunk_len);
append_bytes(ancil_chunks_buf, raw_chunk_buf, &ancil_chunks_len, chunk_len );
//append chunk crc
unsigned char chunk_crc_buf[4];
buf_read(chunk_crc_buf, &pngp, 4);
append_bytes(ancil_chunks_buf, chunk_crc_buf, &ancil_chunks_len, 4);
free(raw_chunk_buf);
DEBUG_PRINT(("ancillary chunks length: %lld\n", ancil_chunks_len));
}
}
//buf contains all idats uncompressed, concatenated
unsigned long unzipped_idats_len = inflate_stream.total_out;
unzip_idats_buf = realloc(unzip_idats_buf, unzipped_idats_len);
//we already have ancillary chunks and idats, don't need the original
free(ENTIRE_PNG_BUF);
inflateEnd(&inflate_stream);
printf("Uncompressed %lld bytes to %ld bytes\n", zipped_idats_len, unzipped_idats_len);
printf("Glitching image data...\n");
for (int g=0;g<NUM_OUTPUT_FILES;g++) {
//do glitches
switch(g) {
case 5:
glitch_random(unzip_idats_buf, unzipped_idats_len,
ihdr_infos.scanline_len, 0.0005);
break;
case 6:
glitch_random_filter(unzip_idats_buf, unzipped_idats_len,
ihdr_infos.scanline_len);
break;
default:
glitch_filter(unzip_idats_buf, unzipped_idats_len,
ihdr_infos.scanline_len, g);
}
//recompress so we can write them to file
long long glitched_idats_len = 0;
unsigned char *glitched_idats = zip_idats(unzip_idats_buf,
unzipped_idats_len, &glitched_idats_len);
if (glitched_idats == NULL) {
DEBUG_PRINT((E_GLITCH));
free (unzip_idats_buf);
free (ancil_chunks_buf);
return -1;
}
char path[MAX_PATH_LENGTH];
bzero(path, MAX_PATH_LENGTH);
snprintf(path, MAX_PATH_LENGTH, "%s%s%s-%d.png", OUTPUT_DIRECTORY, DIR_SEP,
base_file_name, g);
DEBUG_PRINT(("Output file name is %s\n", path));
FILE *outfp = fopen(path, "wb");
write_glitched_image(glitched_idats, glitched_idats_len, ihdr_bytes_buf,
ancil_chunks_buf, ancil_chunks_len, outfp);
printf("%s\n", path);
fflush(stdout);
fclose(outfp);
free(glitched_idats);
}
free(ancil_chunks_buf);
free(unzip_idats_buf);
return 0;
}
int machine_execute (Machine *m) {
assert (m != NULL);
m->IP = 0 ;
int op = m->segment_code[m->IP] ;
int v1, v2 ;
char c ;
int stop = 0 ;
while (!stop) {
switch (op) {
case add :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
m->segment_data[m->SP-2] = v1 + v2 ;
m->SP -- ;
m->IP ++ ;
break ;
case and :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
m->segment_data[m->SP-2] = v1 & v2 ;
m->SP -- ;
m->IP ++ ;
break ;
case call :
m->segment_data[m->SP] = m->IP + 2 ;
m->IP = m->segment_code[m->IP+1] ;
m->SP ++ ;
break ;
case calls :
break ;
case cont :
v1 = m->segment_data[m->segment_data[m->SP-1]] ;
m->segment_data[m->SP-1] = v1 ;
m->IP ++ ;
break ;
case cpy :
v1 = m->segment_code[m->IP+1];
v2 = m->segment_data[m->SP-1] ;
for(c = 0 ; c < v1 ; c++)
m->segment_data[m->SP-1+c] = m->segment_data[v2+c];
m->SP += (v1-1);
m->IP += 2 ;
break ;
case dec :
v1 = m->segment_code [m->IP+1] ;
m->SP -= v1;
if (m->SP < 0)
error_fatal ("pointeur de pile incorrect") ;
m->IP += 2 ;
break ;
case divi :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
m->segment_data[m->SP-2] = v1 / v2 ;
m->SP -- ;
m->IP ++ ;
break ;
case eq :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
if (v1 == v2)
m->segment_data[m->SP-2] = 1 ;
else
m->segment_data[m->SP-2] = 0 ;
m->SP -- ;
m->IP ++ ;
break ;
case gt :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
if (v1 < v2)
m->segment_data[m->SP-2] = 1 ;
else
m->segment_data[m->SP-2] = 0 ;
m->SP -- ;
m->IP ++ ;
break ;
case halt :
stop = 1 ;
break ;
case in :
scanf ("%d", &v1);
m->segment_data[m->segment_data[m->SP-1]] = v1 ;
m->SP -- ;
m->IP ++ ;
break ;
case inc :
v1 = m->segment_code [m->IP+1] ;
m->SP += v1;
if (m->SP >= SEGMENT_DATA_SIZE)
error_fatal ("pointeur de pile incorrect") ;
m->IP += 2 ;
break ;
case jp :
m->IP = m->segment_code[m->IP+1];
break ;
case jf :
if (m->segment_data[m->SP-1] == 0)
m->IP = m->segment_code[m->IP+1];
else
m->IP += 2 ;
m->SP -- ;
break ;
case jl :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
if (v1 > v2)
m->IP = m->segment_code[m->IP+1];
else
m->IP += 2 ;
m->SP -= 2 ;
break ;
case jg :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
if (v1 < v2)
m->IP = m->segment_code[m->IP+1];
else
m->IP += 2 ;
m->SP -= 2 ;
break ;
case les :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
if (v1 > v2)
m->segment_data[m->SP-2] = 1 ;
else
m->segment_data[m->SP-2] = 0 ;
m->SP -- ;
m->IP ++ ;
break ;
case libp :
v1 = m->segment_code[m->IP+1] ;
//v2 = m->segment_data[m->BP + v1] ; pour la donnée et
v2 = m->BP + v1 ; // pour l'adresse
m->segment_data[m->SP] = v2 ;
m->SP ++ ;
m->IP += 2 ;
break ;
case move :
v1 = m->segment_code[m->IP+1] ;
v2 = m->segment_data[m->SP - v1 - 1] ;
for (c = 0 ; c < v1 ; c++)
m->segment_data[v2+c] = m->segment_data[m->SP - v1 + c] ;
m->SP -= (v1 + 1) ;
m->IP += 2 ;
break ;
case mult :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
m->segment_data[m->SP-2] = v1 * v2 ;
m->SP -- ;
m->IP ++ ;
break ;
case neg :
v1 = m->segment_data[m->SP-1] ;
m->segment_data[m->SP-1] = -v1 ;
m->IP ++ ;
break ;
case not :
v1 = m->segment_data[m->SP-1] ;
if (v1 == 0)
m->segment_data[m->SP-1] = 1 ;
else
m->segment_data[m->SP-1] = 0 ;
m->IP ++ ;
break ;
case or :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
m->segment_data[m->SP-2] = v1 | v2 ;
m->SP -- ;
m->IP ++ ;
break ;
case out :
fprintf (stdout, "%d\n", m->segment_data[m->SP-1]) ;
m->SP -- ;
m->IP ++ ;
break ;
case outc :
m->IP++ ;
while ((c = m->segment_code[m->IP++]) != 0)
fprintf (stdout, "%c", c);
break ;
case pow :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
m->segment_data[m->SP-2] = puissance (v2,v1);
m->SP -- ;
m->IP ++ ;
break ;
case push :
m->segment_data[m->SP] = m->segment_code[m->IP+1] ;
m->SP ++ ;
m->IP += 2 ;
break ;
case pushr:
break ;
case ret :
m->IP = m->segment_data[m->SP-1] ;
m->SP -- ;
break ;
case rstrbp :
m->BP =m->segment_data[m->SP-1] ;
m->SP -- ;
m->IP ++ ;
break ;
case savebp :
m->segment_data[m->SP] = m->BP ;
m->BP = m->SP + 1 ;
m->SP ++ ;
m->IP ++ ;
break ;
case sub :
v1 = m->segment_data[m->SP-1] ;
v2 = m->segment_data[m->SP-2] ;
m->segment_data[m->SP-2] = v1 - v2 ;
m->SP -- ;
m->IP ++ ;
break ;
default :
error_fatal ("instruction inconnu") ;
}
op = m->segment_code[m->IP] ;
}
return 0 ;
}
//-----------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------
void Fehler( const char* message )
{
error_fatal( message );
};
// Optional change of configuration (if different from default)
Revolver::Revolver(rpf_parameters& parameters)
{
m_Addr = 0;
m_currentFilter = -1;
char str[80];
m_RPF_parameters.nfw = parameters.nfw ;
m_RPF_parameters.nfilt = parameters.nfilt ;
// filter steps
m_RPF_parameters.step = parameters.step ;
m_RPF_parameters.com = parameters.com ;
m_RPF_parameters.baud = parameters.baud ;
m_RPF_parameters.hold = parameters.hold ;
m_RPF_parameters.torque = parameters.torque ;
m_RPF_parameters.offset = parameters.offset ;
m_RPF_parameters.calspd = parameters.calspd ;
m_RPF_parameters.slope = parameters.slope ;
m_RPF_parameters.stspd = parameters.stspd ;
m_RPF_parameters.enspd = parameters.enspd ;
m_RPF_parameters.feed = parameters.feed ;
m_RPF_parameters.dly = parameters.dly ;
int er = SioReset(m_RPF_parameters.com, 64, 64);
if (er != 0)
{
if (er == IE_BADID)
error_fatal("Init Revolver", "Imposible abrir COM: Puerto inexistente", 0);
if (er == IE_OPEN)
error_fatal("Init Revolver", "Imposible abrir COM: Puerto ya abierto", 0);
if (er == IE_MEMORY)
error_fatal("Init Revolver", "Imposible abrir COM: No hay memoria suficiente", 0);
else
error_fatal("Init Revolver", "Imposible abrir COM", 0);
return;
}
er = SioBaud(m_RPF_parameters.com, m_RPF_parameters.baud);
if (er == IE_BAUDRATE )
{
error_fatal("Init Revolver", "Unsupported boud rate", 0);
return;
}
for(int n = 0; n < m_RPF_parameters.nfw; n++)
{
m_Addr = n;
// Hold
sprintf(str, "9%d", m_RPF_parameters.hold);
Cmd(str);
// Torque value
sprintf(str, "3%04X", m_RPF_parameters.torque);
Cmd(str);
// Offset value
sprintf(str, "4%02X", m_RPF_parameters.offset + 127);
Cmd(str);
// Num. of filters
sprintf(str, "5%02X", m_RPF_parameters.nfilt);
Cmd(str);
// Num. of filters
sprintf(str, "6%03X", m_RPF_parameters.step);
Cmd(str);
// Calibration speed
sprintf(str, "8%04X", m_RPF_parameters.calspd);
Cmd(str);
// Slope
sprintf(str, "A%02X", m_RPF_parameters.slope);
Cmd(str);
// Start speed
sprintf(str, "B%04X", m_RPF_parameters.stspd);
Cmd(str);
// End speed
sprintf(str, "C%04X", m_RPF_parameters.enspd);
Cmd(str);
// Enable feedback
sprintf(str, "L%d", m_RPF_parameters.feed);
Cmd(str);
// Delay after pos.
sprintf(str, "K%04X", m_RPF_parameters.dly);
Cmd(str);
// Calibrate
Calibrate();
}
}
Revolver::Revolver()
{
m_Addr = 0;
m_currentFilter = -1;
char str[80];
// Inicializamos
m_RPF_parameters.nfw = 1;
m_RPF_parameters.nfilt = MAX_FILTROS_DTA;
// filter steps
m_RPF_parameters.step = 800 / m_RPF_parameters.nfilt;
m_RPF_parameters.com = COM5;
m_RPF_parameters.baud = Baud19200;
m_RPF_parameters.hold = 1;
m_RPF_parameters.torque = 15984;
m_RPF_parameters.offset = 0;
m_RPF_parameters.calspd = 20000;
m_RPF_parameters.slope = 255;
m_RPF_parameters.stspd = 65535;
m_RPF_parameters.enspd = 6144;
m_RPF_parameters.feed = 1;
m_RPF_parameters.dly = 125;
//Cargamos
LoadCFG(m_RPF_parameters);
int er = SioReset(m_RPF_parameters.com, 64, 64);
if (er != 0)
{
if (er == IE_BADID)
error_fatal("Init Revolver", "Imposible abrir COM: Puerto inexistente", 0);
if (er == IE_OPEN)
error_fatal("Init Revolver", "Imposible abrir COM: Puerto ya abierto", 0);
if (er == IE_MEMORY)
error_fatal("Init Revolver", "Imposible abrir COM: No hay memoria suficiente", 0);
else
error_fatal("Init Revolver", "Imposible abrir COM", 0);
return;
}
er = SioBaud(m_RPF_parameters.com, m_RPF_parameters.baud);
if (er == IE_BAUDRATE )
{
error_fatal("Init Revolver", "Unsupported boud rate", 0);
return;
}
for(int n = 0; n < m_RPF_parameters.nfw; n++)
{
m_Addr = n;
// Hold
sprintf(str, "9%d", m_RPF_parameters.hold);
if (Cmd(str) == false)
{
AfxMessageBox("*** Init Revolver: No hay respuesta por el puerto COM, asegurese que el dispositivo esta conectado");
exit(-1);
}
// Torque value
sprintf(str, "3%04X", m_RPF_parameters.torque);
Cmd(str);
// Offset value
sprintf(str, "4%02X", m_RPF_parameters.offset + 127);
Cmd(str);
// Num. of filters
sprintf(str, "5%02X", m_RPF_parameters.nfilt);
Cmd(str);
// Num. of filters
sprintf(str, "6%03X", m_RPF_parameters.step);
Cmd(str);
// Calibration speed
sprintf(str, "8%04X", m_RPF_parameters.calspd);
Cmd(str);
// Slope
sprintf(str, "A%02X", m_RPF_parameters.slope);
Cmd(str);
// Start speed
sprintf(str, "B%04X", m_RPF_parameters.stspd);
Cmd(str);
// End speed
sprintf(str, "C%04X", m_RPF_parameters.enspd);
Cmd(str);
// Enable feedback
sprintf(str, "L%d", m_RPF_parameters.feed);
Cmd(str);
// Delay after pos.
sprintf(str, "K%04X", m_RPF_parameters.dly);
Cmd(str);
// Calibrate
Calibrate();
}
}
/*************************** configura_digitalizador *************************
Función para configurar el digitalizador para el formato de imagen que
se desea emplear en la adquisición.
*****************************************************************************/
int configura_digitalizador(int formato)
{
static bool bConfigurado = false;
// Compruebo si los digitalizadores son iguales. Si no son iguales
// libero el digitalizador antiguo, para reservarlo según las nuevas
// especificaciones.
if ( strcmp(paramAux->Cam.formatoDig, paramAux->Cam.formatoDig_e) || !bConfigurado)
{
// Si el digitalizador esta reservado, libero la memoria reservada, para
// poder configurarlo.
if ( M_digitalizador != M_NULL ) libera_digitalizador();
switch (formato) {
case FORMATO_NORMAL:
MdigAlloc (M_sistema, M_DEV0, paramAux->Cam.formatoDig, M_DEFAULT, &M_digitalizador);
break;
case FORMATO_ENFOQUE:
MdigAlloc (M_sistema, M_DEV0, paramAux->Cam.formatoDig_e, M_DEFAULT, &M_digitalizador);
break;
default:
error_fatal("configura_digitalizador", "Formato de digitalización inaceptable", 0);
return 1;
}
// Fijamos los parámetros de adquisición, según los datos leidos del fichero ini.
MdigControl(M_digitalizador, M_BRIGHTNESS, paramAux->Cam.brillo);
MdigControl(M_digitalizador, M_GAIN, paramAux->Cam.ganancia);
ModificaExposicion(paramAux->Rueda.exposicion[paramAux->Rueda.posFiltro]);
ModificaBaseExposicion(paramAux->Rueda.base_exp[paramAux->Rueda.posFiltro]);
}
if (paramAux->Cam.anchoImagen != paramAux->Cam.anchoImagen_e ||
paramAux->Cam.altoImagen != paramAux->Cam.altoImagen_e ||
!bConfigurado)
{
// Selecciono la configuración del digitalizador.
MdigControl(M_digitalizador, M_SOURCE_OFFSET_X, 0); // Necesario para evitar salirnos del cuadro
MdigControl(M_digitalizador, M_SOURCE_OFFSET_Y, 0); // al modificar el tamaño de la captura
switch (formato) {
case FORMATO_NORMAL:
MdigControl(M_digitalizador, M_SOURCE_SIZE_X, paramAux->Cam.anchoImagen);
MdigControl(M_digitalizador, M_SOURCE_OFFSET_X, (limCam.anchoDig - paramAux->Cam.anchoImagen) / 2);
MdigControl(M_digitalizador, M_SOURCE_SIZE_Y, paramAux->Cam.altoImagen);
MdigControl(M_digitalizador, M_SOURCE_OFFSET_Y, (limCam.altoDig - paramAux->Cam.altoImagen) / 2);
// ModificaExposicion(paramAux->Cam.exposicion[paramAux->Mtb.posFiltro]);
break;
case FORMATO_ENFOQUE:
MdigControl(M_digitalizador, M_SOURCE_SIZE_X, paramAux->Cam.anchoImagen_e);
MdigControl(M_digitalizador, M_SOURCE_OFFSET_X, (limCam.anchoDig_e - paramAux->Cam.anchoImagen_e) / 2);
MdigControl(M_digitalizador, M_SOURCE_SIZE_Y, paramAux->Cam.altoImagen_e);
MdigControl(M_digitalizador, M_SOURCE_OFFSET_Y, (limCam.altoDig_e - paramAux->Cam.altoImagen_e) / 2);
// ModificaExposicion(paramAux->Cam.exposicion[paramAux->Mtb.posFiltro]);
break;
}
}
// Nos aseguramos de que lo anterior sólo se ejecuta una vez si el formato y las dimensiones
// del digitalizador son iguales para adquisición normal y autoenfoque
bConfigurado = true;
return 0;
}
/**
* \brief Main application
*/
int main(void)
{
char test_file_name[] = "0:sd_image.bin";
FRESULT res;
FATFS fs;
FIL file_object;
uint32_t len=0;
uint32_t curr_prog_addr=APP_START_ADDRESS;
struct nvm_config config;
UINT iRead=0;
check_boot_mode();
system_init();
delay_init();
irq_initialize_vectors();
cpu_irq_enable();
/* Initialize SD MMC stack */
sd_mmc_init();
nvm_get_config_defaults(&config);
nvm_set_config(&config);
/* Turn ON LED */
port_pin_set_output_level(BOOT_LED, false);
#ifdef __DEBUG_PRINT__
serial_port_init();
printf("\x0C\n\r-- SD/MMC Card FatFs Boot Loader --\n\r");
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
printf("Please plug an SD/MMC card in slot.\n\r");
#endif
/* Wait card present and ready */
sd_mmc_ready();
memset(&fs, 0, sizeof(FATFS));
res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs);
if (FR_INVALID_DRIVE == res) {
#ifdef __DEBUG_PRINT__
printf("[FAIL] Mounting SD card failed result= %d\r\n", res);
#endif
}
#ifdef __DEBUG_PRINT__
printf("Mounting the SD card successful...\r\n");
#endif
res =f_open(&file_object,(const char *)test_file_name,FA_READ);
if(res != FR_OK) error_fatal(FILE_OPEN_ERROR);
do {
if(file_object.fsize > MAX_CODE_SIZE) error_fatal(MAX_SIZE_ERROR);
res = f_read(&file_object, (void *) buff, MAX_BUF_SIZE, &iRead);
if(res != FR_OK) error_fatal(FILE_READ_ERROR);
/* Program the read data into Flash */
if(iRead)
{
program_memory(curr_prog_addr, buff,iRead);
#ifdef __DEBUG_PRINT__
printf("*");
#endif
}
/* Increment the current programming address */
curr_prog_addr += iRead;
len += iRead;
if(len > MAX_CODE_SIZE)
error_fatal(MAX_SIZE_ERROR);
/* Do this till end of file */
} while (iRead != 0);
#ifdef __DEBUG_PRINT__
printf("\r\n[PROGRAMMING COMPLETED]..Resetting !!!!\r\n");
#endif
// Intentionally not closing the file object to reduce code size !!!.
start_application();
while(1);
// Should have reset by now !!!.
}
/*************************** ini_control_digitalizador *********************
Función para reservar memoria para los diferentes formatos de
digitalizadores que se utilizarán en la toma de imágenes.
Previamente, se comprueba que los parámetros iniciales son válidos para
el formato y tipo de digitalizador reservado.
Seguidamente se reserva el display y los buffers que se utilizan en el
proceso de adquisición de imágenes.
*****************************************************************************/
int ini_control_digitalizador(parametros *param)
{
char *fn = "ini_control_digitalizador - ";
int i;
paramAux = param; //para usar en otras funciones
// SI DEFINO UN TAMAÑO DE DIGITALIZADOR DE ENFOQUE... (DIGITALIZADOR)
// Reservo memoria para un nuevo display en el que se mostrarán los campos
// recorridos y los que se han podido enfocar.
if (param->Cam.formatoDig_e[0] != '\0' &&
strcmp(param->Cam.formatoDig, param->Cam.formatoDig_e) )
{
// Configuro el digitalizador en formato enfoque
if (M_digitalizador != M_NULL)
libera_digitalizador();
if ( MdigAlloc (M_sistema, M_DEV0, param->Cam.formatoDig_e, M_DEFAULT, &M_digitalizador)
== M_NULL )
{
error_fatal("ini_control_digitalizador", "Formato incorrecto", 0);
#if !defined (__BORLANDC__)
putch('\a');
#endif
return 1;
}
MdigInquire(M_digitalizador, M_SIZE_X, &limCam.anchoDig_e);
if ( limCam.anchoDig_e > MAX_ANCHO_IMAGEN ||
limCam.anchoDig_e < param->Cam.anchoImagen_e )
{
error_fatal(fn, "Error en los parámetros iniciales", 0);
#if !defined (__BORLANDC__)
putch('\a');
#endif
return 1;
}
MdigInquire(M_digitalizador, M_SIZE_Y, &limCam.altoDig_e);
if ( limCam.altoDig_e > MAX_ALTO_IMAGEN ||
limCam.altoDig_e < param->Cam.altoImagen_e )
{
error_fatal(fn, "Error en los parámetros iniciales", 0);
#if !defined (__BORLANDC__)
putch('\a');
#endif
return 1;
}
}
// Configuro el digitalizador en formato normal.
if (M_digitalizador != M_NULL)
libera_digitalizador();
if ( MdigAlloc (M_sistema, M_DEV0, param->Cam.formatoDig, M_DEFAULT, &M_digitalizador)
== M_NULL ) {
error_fatal("ini_control_proceso_imagenes", "Formato incorrecto", 0);
return 1;
}
MdigInquire(M_digitalizador, M_SIZE_X, &limCam.anchoDig);
if ( limCam.anchoDig > MAX_ANCHO_IMAGEN ||
limCam.anchoDig < param->Cam.anchoImagen ) {
error_fatal(fn, "Error en los parámetros iniciales", 0);
#if !defined (__BORLANDC__)
putch('\a');
#endif
return 1;
}
MdigInquire(M_digitalizador, M_SIZE_Y, &limCam.altoDig);
if ( limCam.altoDig > MAX_ALTO_IMAGEN ||
limCam.altoDig < param->Cam.altoImagen ) {
error_fatal(fn, "Error en los parámetros iniciales", 0);
#if !defined (__BORLANDC__)
putch('\a');
#endif
return 1;
}
// Si el formato del digitalizador de enfoque es el mismo que el de
// captura normal, copiamos las dimensiones porque no se leyeron.
if ( strcmp(param->Cam.formatoDig, param->Cam.formatoDig_e) == 0 ) {
limCam.anchoDig_e = limCam.anchoDig;
limCam.altoDig_e = limCam.altoDig;
}
// Compruebo los valores iniciales de brillo, ganancia y exposición.
if ( info_digitalizador(M_digitalizador) ) {
error_fatal(fn, "Error en los parámetros iniciales", 0);
return 1;
}
// Se centra la camara en el caso de que se haya configurado un tamaño de toma diferente al maximo de la camara
if ( configura_digitalizador(FORMATO_NORMAL) )
return 1;
// Buffer auxiliar de PROFUNDIDAD_ACUMULACION bits para acumular valores.
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, PROFUNDIDAD_ACUMULACION+M_UNSIGNED,
M_IMAGE+M_DISP+M_PROC+M_GRAB, &M_imagen_acum);
if ( M_imagen_acum == M_NULL ) {
error_fatal(fn, "M_imagen_acum", 0);
return 1;
}
// Obtenemos la profundidad de la camara
MdigInquire(M_digitalizador, M_SIZE_BIT , ¶m->Cam.profundidad);
if ( (BITS_CAMARA > 8 && param->Cam.profundidad <= 8) ||
(BITS_CAMARA <= 8 && param->Cam.profundidad > 8) )
{
error_fatal(fn, "BITS_CAMARA (DEFINE en codigo) y profundidad camara no coherentes", 0);
return 1;
}
//Si la profundidad no es de 8bit, hay que configurar el display.
//El display siempre es de 8 bit
if (param->Cam.profundidad == 16)
{
MdispControl(M_display_normal,M_VIEW_MODE,M_BIT_SHIFT);
MdispControl(M_display_normal,M_VIEW_BIT_SHIFT,4); //despreciamos los 4 bits menos significativos
MdispLut(M_display_normal, M_PSEUDO); //esto es necesario para que la intensidad no sea anormalmente elevada
}
// Reservamos los buffers donde se almacenarán y procesarán las imágenes.
// M_imagen1 será el buffer que normalmente estará asociado al display_normal.
// En modo VGA no permite grabar datos en el buffer.
long nSD_size;
MsysInquire(M_sistema,M_SYSTEM_DESCRIPTOR_SIZE,&nSD_size);
char* systemDescriptor = new char[nSD_size];
MsysInquire(M_sistema,M_SYSTEM_DESCRIPTOR,systemDescriptor);
if (systemDescriptor == M_SYSTEM_VGA)
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_PROC, &M_imagen1 );
else
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_GRAB+M_PROC, &M_imagen1 );
delete [ ] systemDescriptor;
if ( M_imagen1 == M_NULL) {
error_fatal(fn, "M_imagen1", 0);
return -1;
}
if ( M_imagen1 != M_NULL )
{
// Seleccionamos el display para imagen normal, asociando el overlay.
#if !defined (__BORLANDC__)
configura_overlay(M_display_normal, M_imagen1, &M_overlay_normal, 1);
#else
configura_overlay(M_display_normal, M_imagen1, HWindow, &M_overlay_normal, 1);
borra_buffer(M_imagen1, NEGRO, 0, 0, NULL, NULL);
#endif
/*
*/
if (param->Cam.anchoImagen != param->Cam.anchoImagen_e ||
param->Cam.altoImagen != param->Cam.altoImagen_e)
{
// Reservo un child buffer de M_imagen1 con el tamaño de enfoque.
MbufChild2d(M_imagen1, (param->Cam.anchoImagen - param->Cam.anchoImagen_e) /2,
(param->Cam.altoImagen- param->Cam.altoImagen_e) /2,
param->Cam.anchoImagen_e, param->Cam.altoImagen_e, &M_centro_imagen);
if (M_centro_imagen == M_NULL)
{
error_fatal(fn, "M_centro_imagen", 0);
return -1;
}
}
else
M_centro_imagen = M_imagen1;
}
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_PROC, &M_imagen2 );
if ( M_imagen2 == M_NULL ) {
error_fatal(fn, "M_imagen2", 0);
return -1;
}
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_PROC, &M_imagen3);
if ( M_imagen3 == M_NULL ) {
error_fatal(fn, "M_imagen3", 0);
return -1;
}
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_PROC, &M_imagen4);
if ( M_imagen4 == M_NULL ) {
error_fatal(fn, "M_imagen4", 0);
return -1;
}
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_PROC, &M_imagen5);
if ( M_imagen5 == M_NULL ) {
error_fatal(fn, "M_imagen5", 0);
return -1;
}
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_PROC, &M_imagen6);
if ( M_imagen6 == M_NULL ) {
error_fatal(fn, "M_imagen6", 0);
return -1;
}
// Reservo memoria para los buffers utilizados en la adquisición
// de las bandas y en la correccion de la iluminación.
for (i=0; i < param->nBandas; i++) {
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_PROC, &M_banda[i]);
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, 32+M_FLOAT,
M_IMAGE+M_PROC, &M_correc_denom[i]);
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, 32+M_FLOAT,
M_IMAGE+M_PROC, &M_correc_numer[i]);
if ( M_banda[i] == M_NULL ||
M_correc_numer[i] == M_NULL || M_correc_denom[i] == M_NULL ) {
error_fatal(fn, "M_banda", 0);
return 1;
}
}
//El resto de filtros no usados a NULL
for (; i < MAX_FILTROS_DTA; i++)
M_banda[i] = M_correc_numer[i] = M_correc_denom[i] = M_NULL;
MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, 32+M_FLOAT,
M_IMAGE+M_PROC, &M_correc_aux);
if ( M_correc_aux == M_NULL ) {
error_fatal(fn, "M_correc_aux", 0);
return 1;
}
// SI DEFINO UN TAMAÑO DE DIGITALIZADOR DE ENFOQUE... (BUFFERS)
// Reservo memoria para los buffers empleados durante el enfoque mediante la funcion determina_contraste2
if ( param->Cam.formatoDig_e[0] != '\0' ) {
MbufAlloc2d(M_sistema, param->Cam.anchoImagen_e, param->Cam.altoImagen_e, param->Cam.profundidad+M_UNSIGNED,
M_IMAGE+M_DISP+M_GRAB+M_PROC, &M_enfoque);
if ( M_enfoque == M_NULL ) {
error_fatal(fn, "M_enfoque", 0);
return 1;
}
}
return 0;
}
int read_seq (FILE *IN, seq_t *seq_holder, char *alphabet) {
char *BUFF, *stock, *p, *q;
int i, state, l;
size_t buffsize, bufflen, seq_len;
/* check if there is something to read */
if ((i = fgetc(IN)) == EOF && feof(IN) != 0) {
return NO_SEQ; }
ungetc(i, IN);
state = SEQ_NONE;
seq_len = bufflen = 0;
buffsize = BUFFSIZE;
seq_holder->seq = NULL;
if ((BUFF = (char *) malloc(sizeof(char) * buffsize+1 )) == NULL)
error_fatal ("memory1" , NULL);
if ((stock = (char *) malloc(sizeof(char) * buffsize+1 )) == NULL)
error_fatal ("memory2" , NULL);
*stock = '\0';
q = stock;
while ((i = fgetc(IN)) != EOF) {
/* skip empty lines */
if (isspace(i)) {continue;}
if ( ungetc(i, IN) == EOF ) error_fatal ("ungetc", NULL);
/* end entry or start entry */
if ( i == '>' ) {
if (state == SEQ_NONE ) state = HEADER;
if (state == SEQ) break ;
}
if (fgets(BUFF, BUFFSIZE + 1, IN) == NULL) break;
/* header processing */
if ( state == HEADER ) {
/* memcopy with '/0' inclusion */
memcpy(q, BUFF, BUFFSIZE+1);
/* is header line completly read */
if (strrchr(BUFF, '\n') == NULL) {
if((stock = realloc(stock, buffsize + BUFFSIZE + 1)) == NULL)
error_fatal("realloc", NULL);
q = stock + buffsize ;
buffsize += BUFFSIZE ;
continue;
}
process_header(seq_holder, stock);
state = SEQ;
buffsize = BUFFSIZE;
p = stock;
*p ='\0';
continue;
}
if ( state == SEQ || state == DUMP ){
/* we clean the buffer before any further use */
if ((l = clean_buff(&BUFF, alphabet)) == -1)
error_fatal(seq_holder->id, "sequence contain spurious characters");
}
if (state == SEQ ) {
bufflen = l;
/* is stock buffer long enough */
if ( seq_len + bufflen >= buffsize ) {
buffsize += BUFFSIZE;
if ((stock = realloc(stock, sizeof(char) * buffsize+1)) == NULL)
error_fatal("Memory3", "Reallocating seq");
}
q = stock + seq_len;
strncpy (q, BUFF, bufflen);
seq_len += bufflen;
}
if ( state == SEQ_NONE ) {
error_fatal("Sequence", "is NOT fasta formated");
}
}
free(BUFF);
if ( state == SEQ ) {
*(stock+seq_len) = '\0';
seq_holder->seq = stock;
}
seq_holder->size = seq_len;
return state;
}
int main(int argc, char* argv[]) {
int mkdir_ret = mkdir(OUTPUT_DIRECTORY, S_IRWXU);
if (mkdir_ret == -1 && errno != EEXIST)
error_fatal(1, "problem creating directory", strerror(errno));
else if (access(OUTPUT_DIRECTORY, W_OK | X_OK))
error_fatal(1, "Problem accessing directory", strerror(errno));
char path[500];
//No commandline arguments, so prompt for path
while (argc <= 1) {
printf("Enter PNG file path: ");
char *s = fgets(path, 499, stdin);
if (s == NULL)
continue;
char *newline = strrchr(s, '\n');
*newline = '\0';
FILE *f = fopen(s, "r");
if (f == NULL) {
printf("Could not open file '%s'\n", s);
continue;
}
fclose(f);
argc++;
argv[1] = path; //Is this out of bounds?
}
for (int i=1;i<argc;i++) {
char *file_path = argv[i];
FILE *f = fopen(file_path, "rb");
if (f == NULL) {
printf("Cannot open file '%s'\n", file_path);
continue;
}
unsigned char* png_buf = calloc(1, 1);
PNG_LENGTH = get_file_buf(f, &png_buf);
printf("Glitching file '%s' (%.2lfM)\n", file_path, PNG_LENGTH / 1024.0 / 1024.0);
if (PNG_LENGTH <= 0) {
printf("File '%s' is empty!\n", file_path);
free(png_buf);
continue;
}
file_path = basename(file_path);
remove_filename_extension(file_path);
//png_buf is passed around to callbacks for libpng, it will be free'd there
begin(file_path, png_buf, PNG_LENGTH);
fclose(f);
}
return 0;
}
/************************** adquierePat ***********************************
Menu previo a la funcion haz_movimiento. Se pide el plano de regresion y los extremos del barrido
Devuelve '-1' si se ha cancelado la toma
bExposicionAjustada - si false, habrá que ajustar la exposicion justo antes de comenzar el barrido
INTERFAZ
SOLO VISUAL
*****************************************************************************/
int adquierePat(parametros *param, char *tipoPat, bool bExposicionAjustada)
{
int nRes;
char mensaje[LONGITUD_TEXTO*2], linea[LONGITUD_TEXTO/2];
point inicio, final;
plane planoRegresion;
plane* pPlanoRegresion = NULL; //si es NULL, no hay plano de regresion definido
// Primero se pide que se enfoque las cuatro esquinas del patron y se calcula el plano de regresion
if (definePlanoRegresion(*param, planoRegresion) == 0)
{
pPlanoRegresion = &planoRegresion;
sprintf(mensaje,"\n+- DEFINE PUNTOS DE ADQUISICIÓN ---------------------------------------+");
strcat(mensaje, "\n| Seleccione (NO ES NECESARIO ENFOCAR) los puntos extremos de una región en la que |");
}
else
{
sprintf(mensaje,"\n+- DEFINE PUNTOS DE ADQUISICIÓN ---------------------------------------+");
strcat(mensaje, "\n| Seleccione (ENFOCANDO) los puntos extremos de una región en la que |");
}
sprintf(linea, "\n| desee adquirir las imágenes del patrón. Se recorrerán %d campos. |",
param->BarridoPatrones.camposEjeX*param->BarridoPatrones.camposEjeY);
strcat(mensaje, linea);
sprintf(linea, "\n| Se capturan las imágenes correspondientes al patrón: %s |",
tipoPat);
strcat(mensaje, linea);
strcat(mensaje, "\n+-------------------------------------------------------------------------+");
CharToOem(mensaje,mensaje);
printf(mensaje);
if (TomaAutomatica.bAutomatica == true)
{
// Caso para realizar la toma de patrones sin iteraccion del usuario
return haz_movimiento(param, &TomaAutomatica.Puntos[0], &TomaAutomatica.Puntos[3], pPlanoRegresion, tipoPat);
}
else
{
if (pPlanoRegresion == NULL)
{
// El usuario debe enfocar
// Se ha de enfocar con el filtro "de enfoque" (o "de referencia", es decir el monocromatico)
Rueda.ChangeFilter(param->filtro[param.Rueda.posEnfoque]);
}
sprintf(mensaje, "Sitúese en un extremo de la región del patrón");
sendop(mensaje);
printf("\n");
nRes = pideP(&inicio);
// OJO: esto se hace porque puede ser que el usuario haya enfocado manualmente antes
// Estamos en el filtro "de enfoque" y sin embargo zPredefinido debe ser calculado para el pancromatico
Rueda.zPredefinido = mspWhere(Z_) + param->Rueda.diferencia_z[param->Rueda.posFiltro] - param->Rueda.diferencia_z[param->filtro[param.Rueda.posEnfoque]] ;
if ( nRes < 0)
{
// se ha punsado ESC
if (pPlanoRegresion == NULL) // si hay plano de regresion, el punto de enfoque nos da igual
// Regresamos al filtro predefinido (o de usuario)
Rueda.ChangeFilter(param->Rueda.posFiltro);
return -1;
}
sprintf(mensaje, "Sitúese en el extremo opuesto de la región del patrón\n");
sendop(mensaje);
nRes = pideP(&final);
// OJO: esto se hace porque puede ser que el usuario haya enfocado manualmente antes
// Estamos en el filtro "de enfoque" y sin embargo zPredefinido debe ser calculado para el pancromatico
Rueda.zPredefinido = mspWhere(Z_) + param->Rueda.diferencia_z[param->Rueda.posFiltro] - param->Rueda.diferencia_z[param->filtro[param.Rueda.posEnfoque]] ;
if ( nRes < 0)
{
// se ha punsado ESC
if (pPlanoRegresion == NULL)
// Regresamos al filtro predefinido (o de usuario)
Rueda.ChangeFilter(param->Rueda.posFiltro);
return -1;
}
printf("\n");
if (pPlanoRegresion == NULL)
{
// El usuario debe enfocar
// Regresamos al filtro predefinido (o de usuario)
Rueda.ChangeFilter(param->Rueda.posFiltro);
}
if (tipoPat == "PAT_CL" && bExposicionAjustada == false)
{
//Ajustamos las exposiciones en el primer extremo antes de barrer
if (pPlanoRegresion != NULL)
{
// Z de enfoque (para el filtro de enfoque) segun el plano de regresion
inicio.coord[Z_] = pPlanoRegresion->A * inicio.coord[X_] + pPlanoRegresion->B * inicio.coord[Y_] + pPlanoRegresion->C;
}
inicio.coord[Z_] += BACKSLASHZ;
mspGoP(inicio); //BACKSLASHZ
inicio.coord[Z_] -= BACKSLASHZ;
mspGoP(inicio);
sendop ("Es obligatorio realizar el ajuste automatico de exposicion al menos una vez. Ajustando exposiciones ...");
AjusteAutomaticoExposicion(M_digitalizador, param);
sendop ("Exposiciones ajustadas. Salvamos las nuevas exposiciones en el archivo de configuracion.");
if (crea_paramRevolver(param->raiz_patrones, param) ) {
error_fatal("control_parametros", "ERROR: No se puede crear el fichero de configuracion. Continuamos con la toma", 0);
}
}
return haz_movimiento(param, &inicio, &final, pPlanoRegresion, tipoPat);
}
}