void device_image_interface::update_names(const device_type device_type, const char *inst, const char *brief)
{
image_interface_iterator iter(device().mconfig().root_device());
int count = 0;
int index = -1;
for (const device_image_interface *image = iter.first(); image != NULL; image = iter.next())
{
if (this == image)
index = count;
if ((image->image_type() == image_type() && device_type==NULL) || (device_type==image->device().type()))
count++;
}
const char *inst_name = (device_type!=NULL) ? inst : device_typename(image_type());
const char *brief_name = (device_type!=NULL) ? brief : device_brieftypename(image_type());
if (count > 1)
{
m_instance_name.printf("%s%d", inst_name , index + 1);
m_brief_instance_name.printf("%s%d", brief_name, index + 1);
}
else
{
m_instance_name = inst_name;
m_brief_instance_name = brief_name;
}
}
image_type load_file( const std::string& filename ) {
fitsfile* f;
int status = 0, naxis;
fits_open_file( &f, filename.c_str(), READONLY, &status );
fits_get_img_dim( f, &naxis, &status );
if( naxis != 2 && naxis != 3 ) {
std::cout << "Could not read image" << std::endl;
fits_close_file( f, &status );
return image_type();
}
long dim[3];
dim[0] = dim[1] = dim[2] = 0;
fits_get_img_size( f, 3, dim, &status );
image_type data( image_type::extents_type( dim[0], dim[1] ) );
typedef CFitsIOTypeMap< image_type::element > map;
int any_null;
unsigned short null = 0;
fits_read_img( f, map::type, 1, data.num_elements(), &null, data.ptr(),
&any_null, &status );
fits_close_file( f, &status );
if( status ) {
fits_report_error( stderr, status );
return image_type();
}
return data;
}
static void gretl_clipboard_get (GtkClipboard *clip,
GtkSelectionData *selection_data,
guint info,
gpointer p)
{
#if 1 || CLIPDEBUG
fprintf(stderr, "gretl_clipboard_get: info = %d (%s)\n",
(int) info, fmt_label(info));
#endif
if (image_type(info)) {
write_plot_for_copy(info);
if (clipboard_buf == NULL) {
return;
}
} else {
if (clipboard_buf == NULL || *clipboard_buf == '\0') {
return;
} else if (info != TARGET_UTF8_STRING) {
/* remove any Unicode minuses (??) */
strip_unicode_minus(clipboard_buf);
}
}
if (info == TARGET_RTF) {
gtk_selection_data_set(selection_data,
GDK_SELECTION_TYPE_STRING,
8, (guchar *) clipboard_buf,
strlen(clipboard_buf));
} else if (image_type(info)) {
gtk_selection_data_set(selection_data,
GDK_SELECTION_TYPE_STRING,
8, (guchar *) clipboard_buf,
clipboard_bytes);
} else {
gtk_selection_data_set_text(selection_data, clipboard_buf, -1);
}
}
void device_image_interface::update_names()
{
image_interface_iterator iter(device().mconfig().root_device());
int count = 0;
int index = -1;
for (const device_image_interface *image = iter.first(); image != NULL; image = iter.next())
{
if (this == image)
index = count;
if (image->image_type() == image_type())
count++;
}
if (count > 1)
{
m_instance_name.printf("%s%d", device_typename(image_type()), index + 1);
m_brief_instance_name.printf("%s%d", device_brieftypename(image_type()), index + 1);
}
else
{
m_instance_name = device_typename(image_type());
m_brief_instance_name = device_brieftypename(image_type());
}
}
void device_image_interface::update_names()
{
const device_image_interface *image = NULL;
int count = 0;
int index = -1;
for (bool gotone = device().mconfig().devicelist().first(image); gotone; gotone = image->next(image))
{
if (this == image)
index = count;
if (image->image_type() == image_type())
count++;
}
if (count > 1) {
m_instance_name.printf("%s%d", device_typename(image_type()), index + 1);
m_brief_instance_name.printf("%s%d", device_brieftypename(image_type()), index + 1);
}
else
{
m_instance_name = device_typename(image_type());
m_brief_instance_name = device_brieftypename(image_type());
}
}
void device_image_interface::update_names(const device_type device_type, const char *inst, const char *brief)
{
int count = 0;
int index = -1;
for (const device_image_interface &image : image_interface_iterator(device().mconfig().root_device()))
{
if (this == &image)
index = count;
if ((image.image_type() == image_type() && device_type == nullptr) || (device_type == image.device().type()))
count++;
}
const char *inst_name = (device_type!=nullptr) ? inst : device_typename(image_type());
const char *brief_name = (device_type!=nullptr) ? brief : device_brieftypename(image_type());
if (count > 1)
{
m_instance_name = string_format("%s%d", inst_name, index + 1);
m_brief_instance_name = string_format("%s%d", brief_name, index + 1);
}
else
{
m_instance_name = inst_name;
m_brief_instance_name = brief_name;
}
}
bool device_image_interface::support_command_line_image_creation() const
{
bool result;
switch (image_type())
{
case IO_PRINTER:
case IO_SERIAL:
case IO_PARALLEL:
// going by the assumption that these device image types should support this
// behavior; ideally we'd get rid of IO_* and just push this to the specific
// devices
result = true;
break;
default:
result = false;
break;
}
return result;
}
void device_image_interface::image_checkhash()
{
device_image_partialhash_func partialhash;
/* only calculate CRC if it hasn't been calculated, and the open_mode is read only */
if (m_hash.first() == NULL && m_readonly && !m_created)
{
/* do not cause a linear read of 600 megs please */
/* TODO: use SHA1 in the CHD header as the hash */
if (image_type() == IO_CDROM)
return;
/* Skip calculating the hash when we have an image mounted through a software list */
if ( m_software_info_ptr )
return;
/* retrieve the partial hash func */
partialhash = get_partial_hash();
run_hash(partialhash, m_hash, hash_collection::HASH_TYPES_ALL);
}
return;
}
void device_image_interface::image_checkhash()
{
device_image_partialhash_func partialhash;
// only calculate CRC if it hasn't been calculated, and the open_mode is read only
UINT32 crcval;
if (!m_hash.crc(crcval) && is_readonly() && !m_created)
{
// do not cause a linear read of 600 megs please
// TODO: use SHA1 in the CHD header as the hash
if (image_type() == IO_CDROM)
return;
// Skip calculating the hash when we have an image mounted through a software list
if ( m_software_info_ptr )
return;
// retrieve the partial hash func
partialhash = get_partial_hash();
run_hash(partialhash, m_hash, util::hash_collection::HASH_TYPES_ALL);
}
return;
}
//----------------------------------------
void Image::loadPGM(const char* aFileName)
//----------------------------------------
{
// Open the file
std::ifstream input_file(aFileName);
// The file does not exist
if (!input_file.is_open())
{
// Build the error message
std::stringstream error_message;
error_message << "Cannot open the file \"" << aFileName << "\". It does not exist";
// Throw an error
throw (error_message.str());
}
// The file is open
else
{
// Release the memory if necessary
destroy();
// Variable to store a line
char p_line_data[LINE_SIZE];
// Get the first line
input_file.getline(p_line_data, LINE_SIZE);
// Get the image type
std::string image_type(p_line_data);
// Invalid format
if (image_type != "P2")
{
//Build the error message
std::stringstream error_message;
error_message << "Invalid file (\"" << aFileName << "\")";
//Throw an error
throw (error_message.str());
}
// Valid format
else
{
// Variable to save the max value
int max_value(-1);
// There is data to read
unsigned int pixel_count(0);
while (input_file.good())
{
// Get the new line
input_file.getline(p_line_data, LINE_SIZE);
// It is not a comment
if (p_line_data[0] != '#')
{
// Store the line in a stream
std::stringstream stream_line;
stream_line << std::string(p_line_data);
// The memory is not allocated
if (!m_p_image && !m_width && !m_height)
{
// Load the image size
stream_line >> m_width >> m_height;
// Alocate the memory
m_p_image = new float[m_width * m_height];
// Out of memory
if (!m_p_image)
{
throw ("Out of memory");
}
}
// The max value is not set
else if (max_value < 0)
{
// Get the max value;
stream_line >> max_value;
}
// Read the pixel data
else
{
// Process all the pixels of the line
while (stream_line.good())
int main(int argc, char *argv[])
{
int ret, rawflag, img_type;
unsigned char *idata, *odata;
int ilen, width, height, depth, ppi, lossyflag;
IHEAD *ihead;
FILE *fp;
char *outext, *ifile, ofile[MAXPATHLEN];
NISTCOM *nistcom;
procargs(argc, argv, &outext, &ifile, &rawflag);
/* Set ppi to unknown */
ppi = -1;
nistcom = (NISTCOM *)NULL;
/* Check image type */
ret = read_raw_from_filesize(ifile, &idata, &ilen);
if(ret)
exit(ret);
ret = image_type(&img_type, idata, ilen);
if(ret) {
free(idata);
exit(ret);
}
free(idata);
/* Open image file for reading based on image type */
if((fp = fopen(ifile,"rb")) == NULL) {
fprintf(stderr, "ERROR: main : fopen : %s\n",ifile);
exit(-1);
}
/* If img_type is ihead ... */
if(img_type == IHEAD_IMG){
/* Read ihead header and check for WSQ_SD14 compression */
ihead = readihdr(fp);
if(atoi(ihead->compress) != WSQ_SD14){
fprintf(stderr, "ERROR : main : input image not WSQ_SD14 compressed\n");
fprintf(stderr, " compression = %d, WSQ_SD14 = %d\n",
atoi(ihead->compress), WSQ_SD14);
fclose(fp);
free(ihead);
exit(-1);
}
/* Get ppi from ihead header */
sscanf(ihead->density,"%d", &ppi);
/* Create a nistcom for the image attributes */
ret = sd_ihead_to_nistcom(&nistcom, ihead, 14);
if(ret) {
fclose(fp);
free(ihead);
exit(ret);
}
free(ihead);
}
/* If image not WSQ_IMG or IHEAD_IMG, ERROR!!! */
else if(img_type != WSQ_IMG) {
fprintf(stderr, "ERROR : main : Invalid image\n");
fprintf(stderr, "Expected a WSQ_SD14 compressed image in\n");
fprintf(stderr, "either raw or ihead format.\n");
fclose(fp);
exit(-1);
}
/* Decode compressed image */
ret = wsq14_decode_file(&odata, &width, &height, &depth, &lossyflag, fp);
if(ret){
fclose(fp);
if(img_type == IHEAD_IMG)
freefet(nistcom);
exit(ret);
}
fclose(fp);
if(debug > 1)
fprintf(stderr, "Image pixmap constructed\n");
/* Combine image attributes into current nistcom */
ret = combine_wsq_nistcom(&nistcom, width, height, depth, ppi, lossyflag, -1.0);
if(ret){
if(img_type == IHEAD_IMG)
freefet(nistcom);
free(odata);
exit(ret);
}
ret = del_wsq_nistcom(nistcom);
if(ret){
free(odata);
freefet(nistcom);
exit(ret);
}
fileroot(ifile);
sprintf(ofile, "%s.%s", ifile, NCM_EXT);
/* Write NISTCOM */
ret = writefetfile_ret(ofile, nistcom);
if(ret){
freefet(nistcom);
free(odata);
exit(ret);
}
freefet(nistcom);
/* Write decompressed image */
sprintf(ofile, "%s.%s", ifile, outext);
ret = write_raw_or_ihead(!rawflag, ofile, odata, width, height, depth, ppi);
if(ret){
free(odata);
exit(ret);
}
free(odata);
if(debug > 1)
fprintf(stderr, "Image pixmap written to %s\n", ofile);
exit(0);
}
edge_image_type IonDetector::canny_edge( const image_type& img ) {
image_type::extents_type three( 3, 3 );
Kernel gaussian( image_type( three, boost::assign::list_of
( 1./16 )( 2./16 )( 1./16 )
( 2./16 )( 4./16 )( 2./16 )
( 1./16 )( 2./16 )( 1./16 ) ) );
Kernel sobelx( image_type( three, boost::assign::list_of
(1)(0)(-1)(2)(0)(-2)(1)(0)(-1) ) );
Kernel sobely( image_type( three, boost::assign::list_of
(1)(2)(1)(0)(0)(0)(-1)(-2)(-1) ) );
image_type img_gauss( img.extents ), img_sobelx( img.extents ),
img_sobely( img.extents );
//gaussian.apply_kernel( img, img_gauss );
sobelx.apply_kernel( img, img_sobelx );
sobely.apply_kernel( img, img_sobely );
save_file( "orig.fits", img );
//save_file( "gauss.fits", img_gauss );
//save_file( "sobelx.fits", img_sobelx );
//save_file( "sobely.fits", img_sobely );
image_type img_sobel( img_sobelx.extents );
edge_image_type edges( img_sobelx.extents );
image_type::element mean = 0, std_dev = 0;
for( image_type::index i = 2; i < img_sobelx.extents.first-2; ++i )
for( image_type::index j = 2; j < img_sobelx.extents.second-2; ++j ) {
image_type::element val = img_sobelx( i, j )*img_sobelx( i, j ) +
img_sobely( i, j )*img_sobely( i, j );
img_sobel( i, j ) = val;
mean += val;
}
save_file( "sobel.fits", img_sobel );
mean /= img_sobel.num_elements();
for( image_type::index i = 2; i<img_sobelx.extents.first-2; ++i )
for( image_type::index j = 2; j<img_sobelx.extents.second-2; ++j ) {
std_dev += ( img_sobel( i, j ) - mean )*
( img_sobel( i, j ) - mean );
}
std_dev = sqrt(std_dev / img_sobel.num_elements());
image_type::element thresh = mean + canny_threshold * std_dev;
image_type::element continue_thresh = mean +
canny_continue_threshold * std_dev;
// First mark off edges with a high threshold
for( image_type::index i = 2; i<img_sobelx.extents.first-2; ++i )
for( image_type::index j = 2; j<img_sobelx.extents.second-2; ++j ) {
edge_image_type::position pos( i, j );
if( edges( pos ) ) continue;
if( canny_check( img_sobel, img_sobelx, img_sobely,
pos, thresh ) ) {
std::stack< image_type::position > checks;
checks.push( pos );
while( !checks.empty() ) {
pos = checks.top();
checks.pop();
if( edges( pos ) ) continue;
if( !canny_check( img_sobel, img_sobelx, img_sobely,
pos, continue_thresh ) )
continue;
edges( pos ) = 1.0f;
pos.first++; checks.push( pos );
pos.second++; checks.push( pos );
pos.second-=2; checks.push( pos );
pos.first--; checks.push( pos );
pos.second+=2; checks.push( pos );
pos.first--; checks.push( pos );
pos.second--; checks.push( pos );
pos.second--; checks.push( pos );
}
}
}
save_file( "edges.fits", edges );
return edges;
}
