gerbv.h

Go to the documentation of this file.

/*
 * gEDA - GNU Electronic Design Automation
 * This file is a part of gerbv.
 *
 *   Copyright (C) 2000-2003 Stefan Petersen (spe@stacken.kth.se)
 *
 * $Id$
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
 */




#ifndef __GERBV_H__
#define __GERBV_H__

#if defined(__cplusplus)
extern "C" {
#endif

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <glib.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkkeysyms.h>

#ifndef RENDER_USING_GDK
# include <cairo.h>
#endif

#define APERTURE_MIN 10
#define APERTURE_MAX 9999

/*
 * Maximum number of aperture parameters is set by the outline aperture
 * macro. There (p. 28) is defined up to 50 points in polygon.
 * So 50 points with x and y plus two for holding extra data gives...
 */
#define APERTURE_PARAMETERS_MAX 102
#define INITIAL_SCALE 200
#define MAX_ERRMSGLEN 25
#define MAX_COORDLEN 28
#define MAX_DISTLEN 180
#define MAX_STATUSMSGLEN (MAX_ERRMSGLEN+MAX_COORDLEN+MAX_DISTLEN)

/* Macros to convert between unscaled gerber coordinates and other units */
/* XXX NOTE: Currently unscaled units are assumed as inch, this is not
   XXX necessarily true for all files */
#define COORD2INS(c) (c)
#define COORD2MILS(c) ((c)*1000.0)
#define COORD2MMS(c) ((c)*25.4)

#define GERB_FATAL_ERROR(...) g_log(NULL, G_LOG_LEVEL_ERROR, __VA_ARGS__)
#define GERB_COMPILE_ERROR(...)  g_log(NULL, G_LOG_LEVEL_CRITICAL, __VA_ARGS__)
#define GERB_COMPILE_WARNING(...)  g_log(NULL, G_LOG_LEVEL_WARNING, __VA_ARGS__)
#define GERB_MESSAGE(...)  g_log(NULL, G_LOG_LEVEL_MESSAGE, __VA_ARGS__)

typedef enum {GERBV_OPCODE_NOP, 
             GERBV_OPCODE_PUSH, 
             GERBV_OPCODE_PPUSH, 
             GERBV_OPCODE_PPOP, 
             GERBV_OPCODE_ADD, 
             GERBV_OPCODE_SUB, 
             GERBV_OPCODE_MUL, 
             GERBV_OPCODE_DIV, 
             GERBV_OPCODE_PRIM 
} gerbv_opcodes_t;

typedef enum {GERBV_MESSAGE_FATAL, 
              GERBV_MESSAGE_ERROR, 
              GERBV_MESSAGE_WARNING, 
              GERBV_MESSAGE_NOTE 
} gerbv_message_type_t;

typedef enum {GERBV_APTYPE_NONE, 
              GERBV_APTYPE_CIRCLE, 
              GERBV_APTYPE_RECTANGLE, 
              GERBV_APTYPE_OVAL, 
              GERBV_APTYPE_POLYGON, 
              GERBV_APTYPE_MACRO, 
              GERBV_APTYPE_MACRO_CIRCLE, 
              GERBV_APTYPE_MACRO_OUTLINE, 
              GERBV_APTYPE_MACRO_POLYGON, 
              GERBV_APTYPE_MACRO_MOIRE, 
              GERBV_APTYPE_MACRO_THERMAL, 
              GERBV_APTYPE_MACRO_LINE20, 
              GERBV_APTYPE_MACRO_LINE21, 
              GERBV_APTYPE_MACRO_LINE22 
} gerbv_aperture_type_t;

typedef enum {GERBV_APERTURE_STATE_OFF, 
              GERBV_APERTURE_STATE_ON, 
              GERBV_APERTURE_STATE_FLASH 
} gerbv_aperture_state_t;

typedef enum {GERBV_UNIT_INCH, 
              GERBV_UNIT_MM, 
              GERBV_UNIT_UNSPECIFIED 
} gerbv_unit_t;

typedef enum {GERBV_POLARITY_POSITIVE, 
              GERBV_POLARITY_NEGATIVE, 
              GERBV_POLARITY_DARK, 
              GERBV_POLARITY_CLEAR 
} gerbv_polarity_t;

typedef enum {GERBV_OMIT_ZEROS_LEADING, 
              GERBV_OMIT_ZEROS_TRAILING, 
              GERBV_OMIT_ZEROS_EXPLICIT, 
              GERBV_OMIT_ZEROS_UNSPECIFIED 
} gerbv_omit_zeros_t;

typedef enum {GERBV_COORDINATE_ABSOLUTE, 
              GERBV_COORDINATE_INCREMENTAL 
} gerbv_coordinate_t;

typedef enum {GERBV_INTERPOLATION_LINEARx1, 
              GERBV_INTERPOLATION_x10, 
              GERBV_INTERPOLATION_LINEARx01, 
              GERBV_INTERPOLATION_LINEARx001, 
              GERBV_INTERPOLATION_CW_CIRCULAR, 
              GERBV_INTERPOLATION_CCW_CIRCULAR, 
              GERBV_INTERPOLATION_PAREA_START, 
              GERBV_INTERPOLATION_PAREA_END, 
              GERBV_INTERPOLATION_DELETED 
} gerbv_interpolation_t;

typedef enum {GERBV_ENCODING_NONE,
              GERBV_ENCODING_ASCII,
              GERBV_ENCODING_EBCDIC,
              GERBV_ENCODING_BCD,
              GERBV_ENCODING_ISO_ASCII,
              GERBV_ENCODING_EIA
} gerbv_encoding_t;

typedef enum {
              GERBV_LAYERTYPE_RS274X, 
              GERBV_LAYERTYPE_DRILL, 
              GERBV_LAYERTYPE_PICKANDPLACE_TOP, 
              GERBV_LAYERTYPE_PICKANDPLACE_BOT, 
} gerbv_layertype_t;

typedef enum {GERBV_KNOCKOUT_TYPE_NOKNOCKOUT,
              GERBV_KNOCKOUT_TYPE_FIXEDKNOCK,
              GERBV_KNOCKOUT_TYPE_BORDER
} gerbv_knockout_type_t;

typedef enum {GERBV_MIRROR_STATE_NOMIRROR,
              GERBV_MIRROR_STATE_FLIPA,
              GERBV_MIRROR_STATE_FLIPB,
              GERBV_MIRROR_STATE_FLIPAB
} gerbv_mirror_state_t;

typedef enum {GERBV_AXIS_SELECT_NOSELECT,
              GERBV_AXIS_SELECT_SWAPAB
} gerbv_axis_select_t;

typedef enum {GERBV_JUSTIFY_NOJUSTIFY,
              GERBV_JUSTIFY_LOWERLEFT,
              GERBV_JUSTIFY_CENTERJUSTIFY
} gerbv_image_justify_type_t;

typedef enum {GERBV_SELECTION_EMPTY, 
              GERBV_SELECTION_POINT_CLICK, 
              GERBV_SELECTION_DRAG_BOX 
} gerbv_selection_t;

typedef enum {GERBV_RENDER_TYPE_GDK, 
              GERBV_RENDER_TYPE_GDK_XOR, 
              GERBV_RENDER_TYPE_CAIRO_NORMAL, 
              GERBV_RENDER_TYPE_CAIRO_HIGH_QUALITY, 
              GERBV_RENDER_TYPE_MAX 
} gerbv_render_types_t;

/* 
 * The following typedef's are taken directly from src/hid.h in the
 * pcb project.  The names are kept the same to make it easier to
 * compare to pcb's sources.
 */
    
/* Used for HID attributes (exporting and printing, mostly).
   HA_boolean uses int_value, HA_enum sets int_value to the index and
   str_value to the enumeration string.  HID_Label just shows the
   default str_value.  HID_Mixed is a real_value followed by an enum,
   like 0.5in or 100mm. 
*/
typedef struct {
    int int_value;
    char *str_value;
    double real_value;
} gerbv_HID_Attr_Val;

typedef struct {
    char *name;
    char *help_text;
    enum
       { HID_Label, HID_Integer, HID_Real, HID_String,
         HID_Boolean, HID_Enum, HID_Mixed, HID_Path
       } type;
    int min_val, max_val;   /* for integer and real */
    gerbv_HID_Attr_Val default_val;       /* Also actual value for global attributes.  */
    const char **enumerations;
    /* If set, this is used for global attributes (i.e. those set
       statically with REGISTER_ATTRIBUTES below) instead of changing
       the default_val.  Note that a HID_Mixed attribute must specify a
       pointer to gerbv_HID_Attr_Val here, and HID_Boolean assumes this is
       "char *" so the value should be initialized to zero, and may be
       set to non-zero (not always one).  */
    void *value;
    int hash; /* for detecting changes. */
} gerbv_HID_Attribute;
/* end of HID attributes from PCB */

typedef struct error_list {
    int layer;
    gchar *error_text;
    gerbv_message_type_t type;
    struct error_list *next;
} gerbv_error_list_t;

typedef struct instruction {
    gerbv_opcodes_t opcode;
    union {
       int ival;
       float fval;
    } data;
    struct instruction *next;
} gerbv_instruction_t;

typedef struct amacro {
    gchar *name;
    gerbv_instruction_t *program;
    unsigned int nuf_push;  /* Nuf pushes in program to estimate stack size */
    struct amacro *next;
} gerbv_amacro_t;

typedef struct gerbv_simplified_amacro {
    gerbv_aperture_type_t type;
    double parameter[APERTURE_PARAMETERS_MAX];
    struct gerbv_simplified_amacro *next;
} gerbv_simplified_amacro_t;

typedef struct gerbv_aperture {
    gerbv_aperture_type_t type;
    gerbv_amacro_t *amacro;
    gerbv_simplified_amacro_t *simplified;
    double parameter[APERTURE_PARAMETERS_MAX];
    int nuf_parameters;
    gerbv_unit_t unit;
} gerbv_aperture_t;

/* the gerb_aperture_list is used to keep track of 
 * apertures used in stats reporting */
typedef struct gerbv_aperture_list {
    int number;
    int layer;
    int count;
    gerbv_aperture_type_t type;
    double parameter[5];
    struct gerbv_aperture_list *next;
} gerbv_aperture_list_t;

typedef struct {
    gerbv_error_list_t *error_list;
    gerbv_aperture_list_t *aperture_list;
    gerbv_aperture_list_t *D_code_list;

    int layer_count;
    int G0;
    int G1;
    int G2;
    int G3;
    int G4;
    int G10;
    int G11;
    int G12;
    int G36;
    int G37;
    int G54;
    int G55;
    int G70;
    int G71;
    int G74;
    int G75;
    int G90;
    int G91;
    int G_unknown;

    int D1;
    int D2;
    int D3;
/*    GHashTable *D_user_defined; */
    int D_unknown;
    int D_error;

    int M0;
    int M1;
    int M2;
    int M_unknown;

    int X;
    int Y;
    int I;
    int J;

    /* Must include % RS-274 codes */
    int star;
    int unknown;

} gerbv_stats_t;

typedef struct drill_list {
    int drill_num;
    double drill_size;
    gchar *drill_unit;
    int drill_count;
    struct drill_list *next;
} gerbv_drill_list_t;

typedef struct {
    int layer_count;
    
    gerbv_error_list_t *error_list;
    gerbv_drill_list_t *drill_list;
    int comment;
    int F;

    int G00;
    int G01;
    int G02;
    int G03;
    int G04;
    int G05;
    int G85;
    int G90;
    int G91;
    int G93;
    int G_unknown;

    int M00;
    int M01;
    int M18;
    int M25;
    int M30;
    int M31;
    int M45;
    int M47;
    int M48;
    int M71;
    int M72;
    int M95;
    int M97;
    int M98;
    int M_unknown;

    int R;

    int unknown;

    /* used to total up the drill count across all layers/sizes */
    int total_count;

    char *detect;

} gerbv_drill_stats_t;

typedef struct {
       gpointer image;
       gpointer net;
} gerbv_selection_item_t;

typedef struct {
       gerbv_selection_t type;
       gdouble lowerLeftX;
       gdouble lowerLeftY;
       gdouble upperRightX;
       gdouble upperRightY;
       GArray *selectedNodeArray;
} gerbv_selection_info_t;

typedef struct {
    gdouble translateX; 
    gdouble translateY; 
    gdouble scaleX; 
    gdouble scaleY; 
    gdouble rotation; 
    gboolean mirrorAroundX;  
    gboolean mirrorAroundY;  
    gboolean inverted; 
} gerbv_user_transformation_t;

typedef struct {
    double left; 
    double right; 
    double bottom; 
    double top; 
} gerbv_render_size_t;

typedef struct gerbv_cirseg {
    double cp_x;   /* center point x */
    double cp_y;   /* center point y */
    double width;  /* of oval */
    double height; /* of oval */
    double angle1;
    double angle2;
} gerbv_cirseg_t;

typedef struct gerbv_step_and_repeat { /* SR parameters */
    int X;
    int Y;
    double dist_X;
    double dist_Y;
} gerbv_step_and_repeat_t;
 
typedef struct {
    gboolean firstInstance;
    gerbv_knockout_type_t type;
    gerbv_polarity_t polarity;
    gdouble lowerLeftX;
    gdouble lowerLeftY;
    gdouble width;
    gdouble height;
    gdouble border;
} gerbv_knockout_t;
 
typedef struct {
    gerbv_step_and_repeat_t stepAndRepeat; 
    gerbv_knockout_t knockout; 
    gdouble rotation; 
    gerbv_polarity_t polarity; 
    gchar *name; 
    gpointer next; 
} gerbv_layer_t;

typedef struct {
    gerbv_axis_select_t axisSelect; 
    gerbv_mirror_state_t mirrorState; 
    gerbv_unit_t unit; 
    gdouble offsetA; 
    gdouble offsetB; 
    gdouble scaleA; 
    gdouble scaleB; 
    gpointer next; 
} gerbv_netstate_t;

typedef struct gerbv_net {
    double start_x; 
    double start_y; 
    double stop_x; 
    double stop_y; 
    gerbv_render_size_t boundingBox; 
    int aperture; 
    gerbv_aperture_state_t aperture_state; 
    gerbv_interpolation_t interpolation; 
    gerbv_cirseg_t *cirseg; 
    struct gerbv_net *next; 
    GString *label; 
    gerbv_layer_t *layer; 
    gerbv_netstate_t *state; 
} gerbv_net_t;

typedef struct gerbv_format {
    gerbv_omit_zeros_t omit_zeros;
    gerbv_coordinate_t coordinate;
    int x_int;
    int x_dec;
    int y_int;
    int y_dec;
    int lim_seqno; /* Length limit for codes of sequence number */
    int lim_gf;    /* Length limit for codes of general function */
    int lim_pf;    /* Length limit for codes of plot function */
    int lim_mf;    /* Length limit for codes of miscellaneous function */
} gerbv_format_t;
       

typedef struct gerbv_image_info {
    char *name;
    gerbv_polarity_t polarity;
    double min_x; /* Always in inches */
    double min_y;
    double max_x;
    double max_y;
    double offsetA;
    double offsetB;
    gerbv_encoding_t encoding;
    double imageRotation;
    gerbv_image_justify_type_t imageJustifyTypeA;
    gerbv_image_justify_type_t imageJustifyTypeB;
    gdouble imageJustifyOffsetA;
    gdouble imageJustifyOffsetB;
    gdouble imageJustifyOffsetActualA;
    gdouble imageJustifyOffsetActualB;
    gchar *plotterFilm;

    /* Descriptive string for the type of file (rs274-x, drill, etc)
     * that this is
     */
    gchar *type;

    /* Attribute list that is used to hold all sorts of information
     * about how the layer is to be parsed.
    */ 
    gerbv_HID_Attribute *attr_list;
    int n_attr;
} gerbv_image_info_t;

typedef struct {
  gerbv_layertype_t layertype; 
  gerbv_aperture_t *aperture[APERTURE_MAX]; 
  gerbv_layer_t *layers; 
  gerbv_netstate_t *states; 
  gerbv_amacro_t *amacro; 
  gerbv_format_t *format; 
  gerbv_image_info_t *info; 
  gerbv_net_t *netlist; 
  gerbv_stats_t *gerbv_stats; 
  gerbv_drill_stats_t *drill_stats;  
} gerbv_image_t;

typedef struct {
  gerbv_image_t *image; 
  GdkColor color; 
  guint16 alpha; 
  gboolean isVisible; 
  gpointer privateRenderData; 
  gchar *fullPathname; 
  gchar *name; 
  gerbv_user_transformation_t transform; 
  gboolean layer_dirty;  
} gerbv_fileinfo_t;

typedef struct {
       double x1, y1;
       double x2, y2;
} gerbv_bbox_t;

typedef struct {
  GdkColor  background; 
  int max_files; 
  gerbv_fileinfo_t **file; 
  int curr_index; 
  int last_loaded; 
  int renderType; 
  gboolean check_before_delete;  
  gchar *path; 
  gchar *execpath;    
  gchar *execname;    
  gchar *project;     
} gerbv_project_t;

typedef struct{
    unsigned char red;
    unsigned char green;
    unsigned char blue;
    unsigned char alpha;
}gerbv_layer_color;

typedef struct {
       gdouble scaleFactorX; 
       gdouble scaleFactorY; 
       gdouble lowerLeftX; 
       gdouble lowerLeftY; 
       gerbv_render_types_t renderType; 
       gint displayWidth; 
       gint displayHeight; 
} gerbv_render_info_t;

gerbv_image_t *gerbv_create_image(gerbv_image_t *image, 
              const gchar *type 
);

void gerbv_destroy_image(gerbv_image_t *image 
);

void
gerbv_image_copy_image (gerbv_image_t *sourceImage, 
       gerbv_user_transformation_t *transform, 
       gerbv_image_t *destinationImage 
);

gerbv_image_t *
gerbv_image_duplicate_image (gerbv_image_t *sourceImage, 
       gerbv_user_transformation_t *transform 
);

void
gerbv_image_delete_net (gerbv_net_t *currentNet 
);

void
gerbv_image_delete_selected_nets (gerbv_image_t *sourceImage, GArray *selectedNodeArray);

gboolean
gerbv_image_reduce_area_of_selected_objects (GArray *selectionArray, gdouble areaReduction, gint paneRows,
              gint paneColumns, gdouble paneSeparation);

gboolean
gerbv_image_move_selected_objects (GArray *selectionArray, gdouble translationX,
              gdouble translationY);

gerbv_net_t *
gerbv_image_return_next_renderable_object (gerbv_net_t *oldNet);

gerbv_project_t *
gerbv_create_project (void);

void
gerbv_destroy_project (gerbv_project_t *gerbvProject 
);

void 
gerbv_open_layer_from_filename (
       gerbv_project_t *gerbvProject, 
       gchar *filename 
);

void 
gerbv_open_layer_from_filename_with_color(gerbv_project_t *gerbvProject, 
       gchar *filename, 
       guint16 red, 
       guint16 green, 
       guint16 blue, 
       guint16 alpha 
);

void
gerbv_destroy_fileinfo (gerbv_fileinfo_t *fileInfo 
);

gboolean 
gerbv_save_layer_from_index(gerbv_project_t *gerbvProject, gint index, gchar *filename);

int
gerbv_revert_file(gerbv_project_t *gerbvProject, int idx);

void 
gerbv_revert_all_files(gerbv_project_t *gerbvProject);

void 
gerbv_unload_layer(gerbv_project_t *gerbvProject, int index);

void 
gerbv_unload_all_layers (gerbv_project_t *gerbvProject);

void 
gerbv_change_layer_order(gerbv_project_t *gerbvProject, gint oldPosition, gint newPosition);

gint
gerbv_add_parsed_image_to_project (gerbv_project_t *gerbvProject, gerbv_image_t *parsed_image,
                     gchar *filename, gchar *baseName, int idx, int reload);
int
gerbv_open_image(gerbv_project_t *gerbvProject, char *filename, int idx, int reload,
              gerbv_HID_Attribute *fattr, int n_fattr, gboolean forceLoadFile);
              
void
gerbv_render_get_boundingbox(gerbv_project_t *gerbvProject, gerbv_render_size_t *boundingbox);

void
gerbv_render_zoom_to_fit_display (gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo 
);

void
gerbv_render_translate_to_fit_display (gerbv_project_t *gerbvProject, gerbv_render_info_t *renderInfo);

void
gerbv_render_to_pixmap_using_gdk (gerbv_project_t *gerbvProject, GdkPixmap *pixmap,
              gerbv_render_info_t *renderInfo, gerbv_selection_info_t *selectionInfo,
              GdkColor *selectionColor);

#ifndef RENDER_USING_GDK
void
gerbv_render_all_layers_to_cairo_target_for_vector_output (gerbv_project_t *gerbvProject,
              cairo_t *cr, gerbv_render_info_t *renderInfo);

void
gerbv_render_all_layers_to_cairo_target (gerbv_project_t *gerbvProject, cairo_t *cr,
                     gerbv_render_info_t *renderInfo);

void
gerbv_render_layer_to_cairo_target (cairo_t *cr, 
              gerbv_fileinfo_t *fileInfo, 
              gerbv_render_info_t *renderInfo 
);
                                          
void
gerbv_render_cairo_set_scale_and_translation(cairo_t *cr, gerbv_render_info_t *renderInfo);

void
gerbv_render_layer_to_cairo_target_without_transforming(cairo_t *cr, gerbv_fileinfo_t *fileInfo, gerbv_render_info_t *renderInfo, gboolean pixelOutput );
#endif

double
gerbv_get_tool_diameter(int toolNumber
);

int
gerbv_process_tools_file(const char *toolFileName
);

void
gerbv_export_png_file_from_project_autoscaled (
              gerbv_project_t *gerbvProject, 
              int widthInPixels, 
              int heightInPixels, 
              gchar const* filename  
);

void
gerbv_export_png_file_from_project (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename 
);

void
gerbv_export_pdf_file_from_project_autoscaled (
              gerbv_project_t *gerbvProject, 
              gchar const* filename  
);

void
gerbv_export_pdf_file_from_project (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename 
);

void
gerbv_export_postscript_file_from_project_autoscaled (
              gerbv_project_t *gerbvProject, 
              gchar const* filename  
);

void
gerbv_export_postscript_file_from_project (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename 
);

void
gerbv_export_svg_file_from_project_autoscaled (
              gerbv_project_t *gerbvProject, 
              gchar const* filename  
);

void
gerbv_export_svg_file_from_project (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename 
);

gerbv_image_t *
gerbv_create_rs274x_image_from_filename (gchar *filename 
);

gboolean
gerbv_export_rs274x_file_from_image (gchar *filename, 
              gerbv_image_t *image, 
              gerbv_user_transformation_t *transform 
);

gboolean
gerbv_export_drill_file_from_image (gchar *filename, 
              gerbv_image_t *image, 
              gerbv_user_transformation_t *transform 
);

void
gerbv_image_create_line_object (gerbv_image_t *image, 
              gdouble startX, 
              gdouble startY, 
              gdouble endX, 
              gdouble endY, 
              gdouble lineWidth, 
              gerbv_aperture_type_t apertureType  
);

void
gerbv_image_create_arc_object (gerbv_image_t *image, 
              gdouble centerX, 
              gdouble centerY, 
              gdouble radius, 
              gdouble startAngle, 
              gdouble endAngle, 
              gdouble lineWidth, 
              gerbv_aperture_type_t apertureType  
);
              
void
gerbv_image_create_rectangle_object (gerbv_image_t *image, 
              gdouble coordinateX, 
              gdouble coordinateY, 
              gdouble width, 
              gdouble height 
);

void
gerbv_image_create_dummy_apertures (gerbv_image_t *parsed_image 
);
              
gerbv_drill_stats_t *
gerbv_drill_stats_new(void);

void
gerbv_drill_stats_destroy(gerbv_drill_stats_t *);

void
gerbv_drill_stats_add_layer(gerbv_drill_stats_t *accum_stats,
              gerbv_drill_stats_t *input_stats,
              int this_layer
);

gerbv_stats_t *
gerbv_stats_new(void);

void
gerbv_stats_destroy(gerbv_stats_t *);

void
gerbv_stats_add_layer(gerbv_stats_t *accum_stats, 
              gerbv_stats_t *input_stats,
              int this_layer
);

void
gerbv_attribute_destroy_HID_attribute (gerbv_HID_Attribute *attributeList, int n_attr);

gerbv_HID_Attribute *
gerbv_attribute_dup (gerbv_HID_Attribute *, int);

#if defined(__cplusplus)
}
#endif

#endif /* __GERBV_H__ */