epr_typconv.c

Insar图像处理软件

    if (field->info->data_type_id == e_tid_uchar) {
        return (float)((uchar*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_char) {
        return (float)((char*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_ushort) {
        return (float)((ushort*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_short) {
        return (float)((short*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_ulong) {
        return (float)((ulong*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_long) {
        return (float)((long*) field->elems)[elem_index];
    }

    epr_set_err(e_err_invalid_data_format, 
                "epr_get_field_elems_as_float: invalid type");

    return 0.0;
}

/**
 * Interprates a memory data as a <code>float</code> data 
 * 
 * @param field the pointer at the array to convert 
 *
 * @return the <code>float</code> typed element
 *         or <code>NULL</code> if an error occured.
 */
const float* epr_get_field_elems_float(const EPR_SField* field)
{
    epr_clear_err();

    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_get_field_elem_as_floats: invalid field name");
        return NULL;
    }
    if (field->info->data_type_id != e_tid_float) {
        epr_set_err(e_err_invalid_data_format, 
                    "epr_get_field_elems_as_floats: invalid type");
        return NULL;
    }
    return (float*) field->elems;
}

/**
 * Interprates a memory as a <code>double</code> value
 * 
 * @param field the pointer at the array to convert 
 * @param elem_index the index of the element 
 * in the given array to convert
 *
 * @return the <code>double</code> typed element
 *         or <code>error_code</code> if an error occured.
 */
double epr_get_field_elem_as_double(const EPR_SField* field, uint elem_index)
{
    epr_clear_err();

    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_get_field_elems_as_double: invalid field name");
        return 0.0;
            
    }
    if (elem_index >= field->info->num_elems) {
        epr_set_err(e_err_invalid_value, 
                    "epr_get_field_elems_as_double: invalid elem_index parameter");
        return 0.0;
    }

    if (field->info->data_type_id == e_tid_double) {
        return (double)((double*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_float) {
        return (double)((float*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_uchar) {
        return (double)((uchar*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_char) {
        return (double)((char*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_ushort) {
        return (double)((ushort*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_short) {
        return (double)((short*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_ulong) {
        return (double)((ulong*) field->elems)[elem_index];
    }
    if (field->info->data_type_id == e_tid_long) {
        return (double)((long*) field->elems)[elem_index];
    }

    epr_set_err(e_err_invalid_data_format, 
                "epr_get_field_elems_as_double: invalid type");

    return 0.0;
}

/**
 * Interprates a memory data as a <code>double</code> data 
 * 
 * @param field the pointer at the array to convert 
 *
 * @return the <code>double</code> typed element
 *         or <code>NULL</code> if an error occured.
 */
const double* epr_get_field_elems_double(const EPR_SField* field)
{
    epr_clear_err();

    epr_clear_err();
    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_get_field_elems_as_doubles: invalid field name");
        return NULL;
    }
    if (field->info->data_type_id != e_tid_double) {
        epr_set_err(e_err_invalid_data_format, 
                    "epr_get_field_elems_as_doubles: invalid type");
        return NULL;
    }
    return (double*) field->elems;
}

/**
 * Interprates a memory data as a <code>short</code> data 
 * 
 * @param field the pointer at the array to convert 
 * @param time the pointer at the time structure to get
 *
 * @return the time [days, seconds, microseconds]
 *         or <code>NULL</code> if an error occured.
 */
const EPR_STime* epr_get_field_elem_as_mjd(const EPR_SField* field)
{
    epr_clear_err();

    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_get_field_elem_as_mjd: invalid field name");
        return NULL;
            
    }
    
    if (field->info->data_type_id != e_tid_time) {
        epr_set_err(e_err_invalid_data_format, 
                    "epr_get_field_elem_as_mjd: invalid type");
        return NULL;
    }

	return (const EPR_STime*) field->elems;
}

/**
 * Interprates a memory data as a string.
 * 
 * @param field the pointer at the array to convert 
 *
 * @return the <code>char</code> typed element
 *         or <code>NULL</code> if an error occured.
 */
const char* epr_get_field_elem_as_str(const EPR_SField* field)
{
    epr_clear_err();

    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_get_field_elem_as_str: invalid field name");
        return NULL;
    }
    if (field->info->data_type_id != e_tid_string) {
        epr_set_err(e_err_invalid_data_format, 
                    "epr_get_field_elem_as_str: invalid type");
        return NULL;
    }
    return (const char*) field->elems;
}




/**
 * Copies the data of the given field into the given buffer of <code>double</code> 
 * elements. The actual number of elements copied is the minimum of the given 
 * number of elements (the buffer's size) and the actual number of elements contained
 * in the field. 
 * <p>If the actual field data type is not <code>double</code> the function automatically
 * performs the conversion.
 * 
 * @param field the field from which to copy the elements
 * @param buffer the buffer in which to copy the data 
 * @param num_elems the number of elements in the given buffer 
 * @return the actual number of elements copied
 */
uint epr_copy_field_elems_as_doubles(const EPR_SField* field, double* buffer, uint num_elems)
{
    uint num_elems_min = 0;
    uint i;

    epr_clear_err();

    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_get_field_elems_as_doubles: invalid field name");
        return num_elems_min;
    }

    num_elems_min = num_elems;
    if (field->info->num_elems < num_elems_min) {
        num_elems_min = field->info->num_elems;
    }

    if (field->info->data_type_id == e_tid_uchar) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (double)((uchar*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_char) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (double)((char*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_ushort) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (double)((ushort*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_short) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (double)((short*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_ulong) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (double)((ulong*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_long) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (double)((long*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_float) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (double)((float*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_double) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (double)((double*) field->elems)[i];
        }
    } else {
        epr_set_err(e_err_invalid_data_format, 
                    "epr_get_field_elems_as_double: invalid type");
        return 0;
    }

    return num_elems_min;
}

/**
 * Copies the data of the given field into the given buffer of <code>float</code> 
 * elements. The actual number of elements copied is the minimum of the given 
 * number of elements (the buffer's size) and the actual number of elements contained
 * in the field. 
 * <p>If the actual field data type is not <code>float</code> the function automatically
 * performs the conversion.
 * 
 * @param field the field from which to copy the elements
 * @param buffer the buffer in which to copy the data 
 * @param num_elems the number of elements in the given buffer 
 * @return the actual number of elements copied
 */
uint epr_copy_field_elems_as_floats(const EPR_SField* field, float* buffer, uint num_elems)
{
    uint num_elems_min = 0;
    uint i;

    epr_clear_err();

    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_copy_field_elems_as_floats: invalid field name");
        return num_elems_min;
    }

    num_elems_min = num_elems;
    if (field->info->num_elems < num_elems_min) {
        num_elems_min = field->info->num_elems;
    }

    if (field->info->data_type_id == e_tid_uchar) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (float)((uchar*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_char) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (float)((char*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_ushort) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (float)((ushort*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_short) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (float)((short*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_ulong) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (float)((ulong*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_long) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (float)((long*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_float) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (float)((float*) field->elems)[i];
        }
    } else {
        epr_set_err(e_err_invalid_data_format, 
                    "epr_copy_field_elems_as_floats: invalid type");
        return 0;
    }

    return num_elems_min;
}

/**
 * Copies the data of the given field into the given buffer of <code>long</code> 
 * elements. The actual number of elements copied is the minimum of the given 
 * number of elements (the buffer's size) and the actual number of elements contained
 * in the field. 
 * <p>If the actual field data type is not <code>long</code> the function automatically
 * performs the conversion.
 * 
 * @param field the field from which to copy the elements
 * @param buffer the buffer in which to copy the data 
 * @param num_elems the number of elements in the given buffer 
 * @return the actual number of elements copied
 */
uint epr_copy_field_elems_as_longs(const EPR_SField* field, long* buffer, uint num_elems)
{
    uint num_elems_min = 0;
    uint i;

    epr_clear_err();

    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_copy_field_elems_as_longs: invalid field name");
        return num_elems_min;
    }

    num_elems_min = num_elems;
    if (field->info->num_elems < num_elems_min) {
        num_elems_min = field->info->num_elems;
    }

    if (field->info->data_type_id == e_tid_uchar) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (long)((uchar*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_char) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (long)((char*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_ushort) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (long)((ushort*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_short) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (long)((short*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_long) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (long)((long*) field->elems)[i];
        }
    } else {
        epr_set_err(e_err_invalid_data_format, 
                    "epr_copy_field_elems_as_longs: invalid type");
        return 0;
    }

    return num_elems_min;
}

/**
 * Copies the data of the given field into the given buffer of <code>ulong</code> 
 * elements. The actual number of elements copied is the minimum of the given 
 * number of elements (the buffer's size) and the actual number of elements contained
 * in the field. 
 * <p>If the actual field data type is not <code>ulong</code> the function automatically
 * performs the conversion.
 * 
 * @param field the field from which to copy the elements
 * @param buffer the buffer in which to copy the data 
 * @param num_elems the number of elements in the given buffer 
 * @return the actual number of elements copied
 */
uint epr_copy_field_elems_as_ulongs(const EPR_SField* field, ulong* buffer, uint num_elems)
{
    uint num_elems_min = 0;
    uint i;

    epr_clear_err();

    if (field == NULL) {
        epr_set_err(e_err_invalid_field_name, 
                    "epr_copy_field_elems_as_ulongs: invalid field name");
        return num_elems_min;
    }

    num_elems_min = num_elems;
    if (field->info->num_elems < num_elems_min) {
        num_elems_min = field->info->num_elems;
    }

    if (field->info->data_type_id == e_tid_uchar) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (ulong)((uchar*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_char) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (ulong)((char*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_ushort) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (ulong)((ushort*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_short) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (ulong)((short*) field->elems)[i];
        }
    } else if (field->info->data_type_id == e_tid_long) {
        for (i = 0; i < num_elems_min; i++) {
            buffer[i] = (ulong)((ulong*) field->elems)[i];
        }
    } else {
        epr_set_err(e_err_invalid_data_format, 
                    "epr_copy_field_elems_as_ulongs: invalid type");
        return 0;
    }

    return num_elems_min;
}
/***************************************************************************************/