degate  0.1.2
Classes | Typedefs | Enumerations | Functions
degate Namespace Reference

The namespace 'degate' is the namespace for everything that belongs to libdegate. More...

Classes

class  AbstractShape
 Represents an abstract shape. More...
class  Annotation
 An annotation is a descriptive meta object that can be placed on a logic model's layer to mark a region of interest. More...
class  AutoNameGates
 This class helps to generate names for gates depending on their position. More...
class  BackgroundClassifierBase
class  BackgroundClassifier
class  BoundingBox
class  CannyEdgeDetection
class  Circle
class  CodeTemplateGenerator
 Base class for code generators. More...
class  ColoredObject
 Represents an object that has a frame and a fill color. More...
class  Configuration
class  ConnectedLogicModelObject
 Represents a logic model object, that can be electrically connected to other logic model objects. More...
class  DeepCopyableBase
class  DeepCopyable
 DeepCopyable is a type for cloneable objects (deep-copyable). More...
class  DegateRuntimeException
 Generic runtime exception in libdegate. More...
class  DegateInconsistencyException
 Represents a runtime exception, that reflects an inconsistency in the logic model or gate library. More...
class  DegateLogicException
 Represents a this-should-not-happen problem and indicates a programming error. More...
class  InvalidPointerException
 This exception is raised if a code fragment receives a null pointer where this should not happen. More...
class  InvalidObjectIDException
 This exception is raised if a method detects an invalid Object ID. More...
class  InvalidXMLException
 Indicates a runtime exception from the XML parser. More...
class  XMLAttributeParseException
 This exception is thrown if a XML importer failed to parse a value of an XML attribute. More...
class  XMLAttributeMissingException
 This exception is thrown if a XML importer detects a missing XML attribute and this XML attribute must be present. More...
class  CollectionLookupException
 This exception is thrown if a method failed to lookup an object in a collection type, such as in a std::map or list. More...
class  SystemException
 This exception indicates, that a system operation failed. More...
class  FileSystemException
 This exception indicates, that a file system operation failed. More...
class  InvalidPathException
 This exception indicates an invalid path in the file system. More...
class  InvalidFileFormatException
 This exception indicates, that libdegate is unable to handle the image file format. More...
class  ZipException
 This exception is thrown if a ZIP archive cannot be exported. More...
class  XMLRPCException
 Indicates a runtime exception from the XML parser. More...
class  DOTAttributes
 Helper class to handle attributes for the dot language. More...
class  DOTExporter
 Base class for a .dot exporter. More...
class  EdgeDetection
class  EMarker
 Representation of an electrically connectable marker object. More...
class  ERCNet
 Electrical Rule Checks that detects unusual net configurations. More...
class  ERCOpenPorts
 Electrical Rule Checks that detects open ports, that means if a port is electrically unconnected. More...
class  Exporter
 This is the base class for exporter classes. More...
class  ExternalMatching
 Run an external program, that analyzes images. More...
class  FilterKernel
 The class FilterKernel implemements a container for 2D filter kernel data. More...
class  SobelXOperator
class  SobelYOperator
class  SobelOperator
class  GaussianBlur
class  LoG
 Implements a Laplacian of Gaussian. More...
class  Gate
 The class Gate defines and implements a physically placed gate. More...
class  GateLibrary
 This class represents a library of template cells. More...
class  GateLibraryExporter
 The GateLibraryExporter exports a gate library. More...
class  GateLibraryImporter
 The GateLibraryImporter imports a gate library. More...
class  GatePort
 This class represents a port of a gate. More...
class  GateTemplate
 A gate template is a container for common properties, that physically placed gates of that type share. More...
class  GateTemplatePort
 This class represents a port of a gate template. More...
class  Grid
 Base class for grid types. More...
class  HlObjectSet
 This class represents a collection of highlighted objects. More...
class  ImageBase
class  Image
 The generic templated class for image objects. More...
class  Image< PixelPolicy, StoragePolicy_PersistentFile >
 Partial template specialization for the storage policy StoragePolicy_PersistentFile. More...
class  Image< PixelPolicy, StoragePolicy_Tile >
 Partial template specialization for the storage policy StoragePolicy_Tile. More...
class  ImageHistogram
class  HueImageHistogram
class  SaturationImageHistogram
class  LightnessImageHistogram
class  RedChannelImageHistogram
class  GreenChannelImageHistogram
class  BlueChannelImageHistogram
class  ImageProcessorBase
 Abstract base class for an image processor. More...
class  ImageReaderBase
 The base class for image readers. More...
class  ImageReaderFactory
 A factory for creating image reader objects. More...
class  ImageWriterBase
 The base class for image readers. More...
class  Importer
 The base class for importers that can parse text files. More...
class  IPConvolve
 Processor: Convolve an image. More...
class  IPCopy
 Processor: Copy an image with auto conversion. More...
class  IPImageWriter
 Processor: Write an image to file. More...
class  IPMedianFilter
 Processor: Median filter a single channel image. More...
class  IPNormalize
 Processor: Normalize a single channel image. More...
class  IPPipe
 Represents an image processing pipe for multiple image processors. More...
class  IPThresholding
 Processor: Create a binary image from a single channel image. More...
class  IrregularGrid
 This class represents a grid type with non equidistant spacing between grid lines. More...
class  JPEGReader
 The JPEGReader parses jpeg images. More...
class  Layer
 Representation of a chip layer. More...
class  Line
class  LinearPrimitive
 Lineare primitive. More...
class  LineSegment
 Line segment. More...
class  LineSegmentMap
 Line segment map. More...
class  LineSegmentExtraction
class  LogicModel
 This class represents the logic model. More...
class  LogicModelDOTExporter
 The LogicModelDOTExporter exports the logic model or a part of the logic model as a dot graph. More...
class  LogicModelExporter
 The LogicModelExporter exports a logic model. More...
class  LogicModelImporter
 This class implements a logic model loader. More...
class  LogicModelObjectBase
 The class LogicModelObjectBase is the base class for basically every class that represents a logic model object. More...
class  LMOCompare
class  LookupSubcircuit
struct  CalculateImageMedianPolicy
 Policy class for image region median calculation. More...
struct  CalculateImageMedianPolicy< ImageType, rgba_pixel_t >
 Policy class for image region median calculation for RGB(A) images. More...
class  MemoryMap
class  MemoryMapBase
class  Module
 Implements a container to build up higher level entities. More...
struct  ErodeImagePolicy
 Policy class for image erosion. More...
struct  DilateImagePolicy
 Policy class for image dilation. More...
class  Net
 The net class represents an electrical potential that is shared between electrically adjacent objects. More...
class  ObjectIDRewriter
 This class is used to defragment object IDs from a logic model. More...
class  ObjectSet
class  PixelPolicy_Base
 Base class for image policies. More...
class  PixelPolicy_RGBA
class  PixelPolicy_GS_DOUBLE
 Represents a greyscale image pixel policy. More...
class  PixelPolicy_GS_BYTE
 Represents a greyscale image pixel policy. More...
class  PlacedLogicModelObject
 Represents a placeable object. More...
class  PluginManager
 The plugin manager that handles complex image processing plugins. More...
class  Point
class  PortColorManager
 The PortColorManager manages color definitions based on common port names. More...
class  ProgressControl
struct  ProjectSnapshot
class  Project
 The project class is a container for project related data. More...
class  ProjectArchiver
 Export a project directory as a ZIP archive. More...
class  ProjectExporter
 The ProjectExporter exports a degate project. More...
class  ProjectImporter
 Parser for degate's project files. More...
struct  get_bbox_trait_selector
struct  get_bbox_trait_selector< true >
class  QuadTree
 Quad tree to store objects and to accesss them with a two dimensional access path. More...
class  down_iterator
class  region_iterator
class  RCBase
 Base class for Rule Checks. More...
class  RCVBlacklistExporter
 The RCVBlacklistExporter exports a set of RC Violations, which should be ignored. More...
class  RCVBlacklistImporter
 The RCVBlacklistImporter imports a list of RC violations, which should be ignored. More...
class  RCVContainer
 Representation for a container type, which holds a list of Rule Check Violations. More...
class  RCViolation
class  Rectangle
class  RegularGrid
 Represents a grid with equidistant spacing between grid lines. More...
class  RemoteObject
class  RuleChecker
class  ScalingManager
 The ScalingManager creates prescaled images for a master image. More...
class  SingletonBase
 This is a base class for singletons. More...
class  StoragePolicy_Base
 Base class for the storage policy of an image. More...
class  StoragePolicy_Memory
 Storage policy for image objects that resists in memory. More...
class  StoragePolicy_File
 Storage policy for image objects that are stored in a file. More...
class  StoragePolicy_TempFile
 Storage policy for image objects that are stored in a temporary file. More...
class  StoragePolicy_PersistentFile
 Storage policy for image objects that are stored in a persistent file. More...
class  SubImageAnalyzer
class  SubProjectAnnotation
 An annotation for subprojects. More...
struct  TemplateMatchingStatistics
 Helper structure for the collection of statistical values. More...
class  Matching
 Base class for matching alorithms. More...
class  TemplateMatching
 This class implements the matching of gate representing images on a background image. More...
class  TemplateMatchingNormal
 This class implements a template matching that basically scans line by line to detect gate placements. More...
class  TemplateMatchingAlongGrid
 This class is the base class for template matching along a grid. More...
class  TemplateMatchingInRows
 This class implements matching for gate template that are aligned in a row. More...
class  TemplateMatchingInCols
 This class implements matching for gate template that are aligned in a column. More...
class  TIFFReader
 The TIFFReader parses tiff images. More...
class  TIFFWriter
 The TIFFWriter parses tiff images. More...
class  TileCacheBase
class  GlobalTileCache
class  TileCache
 The TileCache class handles caching of image tiles. More...
class  StoragePolicy_Tile
 Storage policy for image objects that consists of tiles. More...
struct  assert_is_single_channel_image
 Compile time check for single channel image types. More...
struct  assert_is_multi_channel_image
 Compile time check for multi channel image types. More...
struct  is_pointer
 A pointer trait for the generic type T. More...
struct  is_pointer< T * >
 A pointer trait for the generic type T *. More...
struct  is_pointer< std::shared_ptr< T > >
 A pointer trait for the special shared pointer of type T. More...
struct  call_trait
 Method parameter type trait for pointer and shared pointer. More...
struct  call_trait< T, false >
 Method parameter type trait for normal object that should be passed via reference. More...
struct  is_single_channel_image
 Type trait for multi channel images. More...
struct  is_single_channel_image< rgba_pixel_t >
 Type trait for single channel images. More...
class  VerilogCodeTemplateGenerator
 A code template generator for Verilog. More...
class  VerilogModuleGenerator
class  VerilogTBCodeTemplateGenerator
 A code template generator for Verilog. More...
class  VHDLCodeTemplateGenerator
 A code template generator for VHDL. More...
class  VHDLTBCodeTemplateGenerator
 A code template generator for VHDL. More...
class  Via
 Representation of a via that interconnects layers of a chip. More...
class  ViaMatching
class  Wire
 Represents a wire. More...
class  WireMatching
class  XMLExporter
 A base class for XML exporter. More...
class  XMLImporter
class  ZeroCrossingEdgeDetection

Typedefs

typedef std::pair< unsigned
int, unsigned int > 
coord_type
typedef std::list< coord_typecoord_list
typedef std::vector
< Classifier< coord_type > * > 
classifier_list_type
typedef std::shared_ptr
< CodeTemplateGenerator
CodeTemplateGenerator_shptr
typedef std::shared_ptr
< DeepCopyable
DeepCopyable_shptr
typedef std::shared_ptr< const
DeepCopyable
c_DeepCopyable_shptr
typedef std::shared_ptr
< ExternalMatching
ExternalMatching_shptr
typedef std::shared_ptr
< FilterKernel
FilterKernel_shptr
typedef std::shared_ptr
< SobelXOperator
SobelXOperator_shptr
typedef std::shared_ptr
< SobelYOperator
SobelYOperator_shptr
typedef std::shared_ptr
< SobelOperator
SobelOperator_shptr
typedef std::shared_ptr< LoGLoG_shptr
typedef std::shared_ptr< GateGate_shptr
typedef std::shared_ptr
< GateTemplatePort
GateTemplatePort_shptr
typedef std::shared_ptr< CircleCircle_shptr
typedef std::shared_ptr< LineLine_shptr
typedef std::shared_ptr
< Rectangle
Rectangle_shptr
typedef std::shared_ptr
< ConnectedLogicModelObject
ConnectedLogicModelObject_shptr
typedef std::shared_ptr
< PlacedLogicModelObject
PlacedLogicModelObject_shptr
typedef std::shared_ptr
< RemoteObject
RemoteObject_shptr
typedef std::shared_ptr< NetNet_shptr
typedef std::shared_ptr< GatePortGatePort_shptr
typedef std::shared_ptr
< GateTemplate
GateTemplate_shptr
typedef std::shared_ptr
< GateLibrary
GateLibrary_shptr
typedef std::shared_ptr< LayerLayer_shptr
typedef std::shared_ptr< WireWire_shptr
typedef std::shared_ptr< ViaVia_shptr
typedef std::shared_ptr< EMarkerEMarker_shptr
typedef std::shared_ptr
< Annotation
Annotation_shptr
typedef std::shared_ptr< ModuleModule_shptr
typedef std::shared_ptr
< LogicModel
LogicModel_shptr
typedef unsigned int layer_position_t
typedef uint32_t color_t
 defines the type for colors
typedef unsigned long long object_id_t
typedef unsigned long long layer_id_t
typedef unsigned long long transaction_id_t
typedef unsigned int diameter_t
typedef unsigned int length_t
typedef int pos_t
typedef std::map< ENTITY_COLOR,
color_t
default_colors_t
typedef std::shared_ptr< GridGrid_shptr
typedef std::shared_ptr
< ImageBase
ImageBase_shptr
typedef Image
< PixelPolicy_RGBA,
StoragePolicy_Tile
TileImage_RGBA
 Typedefs for common types of virtual images.
typedef Image
< PixelPolicy_GS_DOUBLE,
StoragePolicy_Tile
TileImage_GS_DOUBLE
typedef Image
< PixelPolicy_GS_BYTE,
StoragePolicy_Tile
TileImage_GS_BYTE
typedef std::shared_ptr
< TileImage_RGBA
TileImage_RGBA_shptr
typedef std::shared_ptr
< TileImage_GS_DOUBLE
TileImage_GS_DOUBLE_shptr
typedef std::shared_ptr
< TileImage_GS_BYTE
TileImage_GS_BYTE_shptr
typedef Image
< PixelPolicy_RGBA,
StoragePolicy_Tile
BackgroundImage
typedef std::shared_ptr
< BackgroundImage
BackgroundImage_shptr
typedef Image
< PixelPolicy_RGBA,
StoragePolicy_TempFile
TempImage_RGBA
typedef Image
< PixelPolicy_GS_DOUBLE,
StoragePolicy_TempFile
TempImage_GS_DOUBLE
typedef Image
< PixelPolicy_GS_BYTE,
StoragePolicy_TempFile
TempImage_GS_BYTE
typedef std::shared_ptr
< TempImage_RGBA
TempImage_RGBA_shptr
typedef std::shared_ptr
< TempImage_GS_DOUBLE
TempImage_GS_DOUBLE_shptr
typedef std::shared_ptr
< TempImage_GS_BYTE
TempImage_GS_BYTE_shptr
typedef Image
< PixelPolicy_RGBA,
StoragePolicy_PersistentFile
PersistentImage_RGBA
typedef std::shared_ptr
< PersistentImage_RGBA
PersistentImage_RGBA_shptr
typedef Image
< PixelPolicy_RGBA,
StoragePolicy_Memory
MemoryImage
typedef std::shared_ptr
< MemoryImage
MemoryImage_shptr
typedef Image
< PixelPolicy_GS_BYTE,
StoragePolicy_Memory
MemoryImage_GS_BYTE
typedef Image
< PixelPolicy_GS_DOUBLE,
StoragePolicy_Memory
MemoryImage_GS_DOUBLE
typedef Image
< PixelPolicy_RGBA,
StoragePolicy_Memory
MemoryImage_RGBA
typedef std::shared_ptr
< MemoryImage_GS_BYTE
MemoryImage_GS_BYTE_shptr
typedef std::shared_ptr
< MemoryImage_GS_DOUBLE
MemoryImage_GS_DOUBLE_shptr
typedef MemoryImage RendererImage
typedef MemoryImage_shptr RendererImage_shptr
typedef MemoryImage GateTemplateImage
typedef MemoryImage_shptr GateTemplateImage_shptr
typedef std::shared_ptr
< ImageProcessorBase
ImageProcessorBase_shptr
typedef std::list< std::string > file_format_collection
typedef std::shared_ptr
< IrregularGrid
IrregularGrid_shptr
typedef std::shared_ptr
< LinearPrimitive
LinearPrimitive_shptr
typedef std::shared_ptr
< LineSegment
LineSegment_shptr
typedef std::shared_ptr
< LineSegmentMap
LineSegmentMap_shptr
typedef std::shared_ptr
< LogicModelObjectBase
LogicModelObjectBase_shptr
typedef std::shared_ptr
< ObjectIDRewriter
ObjectIDRewriter_shptr
typedef uint8_t gs_byte_pixel_t
typedef double gs_double_pixel_t
typedef uint32_t rgba_pixel_t
typedef std::shared_ptr< PointPoint_shptr
typedef std::shared_ptr
< PortColorManager
PortColorManager_shptr
 Typedef for a shared pointer on PortColorManager objects.
typedef std::shared_ptr
< ProgressControl
ProgressControl_shptr
typedef std::list
< std::shared_ptr< Project > > 
ProjectList
typedef std::shared_ptr< ProjectProject_shptr
typedef std::shared_ptr
< ProjectSnapshot
ProjectSnapshot_shptr
typedef std::shared_ptr< RCBaseRCBase_shptr
typedef std::shared_ptr
< RCViolation
RCViolation_shptr
typedef std::shared_ptr
< RegularGrid
RegularGrid_shptr
typedef std::shared_ptr
< ScalingManager
< BackgroundImage > > 
ScalingManager_shptr
 A typedef for scaling managers that handle background images.
typedef std::shared_ptr
< SubProjectAnnotation
SubProjectAnnotation_shptr
typedef std::shared_ptr
< TemplateMatching
TemplateMatching_shptr
typedef std::shared_ptr
< TemplateMatchingNormal
TemplateMatchingNormal_shptr
typedef std::shared_ptr
< TemplateMatchingInRows
TemplateMatchingInRows_shptr
typedef std::shared_ptr
< TemplateMatchingInCols
TemplateMatchingInCols_shptr
typedef std::shared_ptr
< VerilogCodeTemplateGenerator
VerilogCodeTemplateGenerator_shptr
typedef std::shared_ptr
< VerilogTBCodeTemplateGenerator
VerilogTBCodeTemplateGenerator_shptr
typedef std::shared_ptr
< VHDLCodeTemplateGenerator
VHDLCodeTemplateGenerator_shptr
typedef std::shared_ptr
< VHDLTBCodeTemplateGenerator
VHDLTBCodeTemplateGenerator_shptr
typedef std::shared_ptr
< ViaMatching
ViaMatching_shptr
typedef std::shared_ptr
< WireMatching
WireMatching_shptr

Enumerations

enum  ret_t {
  RET_OK = 0,
  RET_ERR = 1,
  RET_INV_PTR = 2,
  RET_MALLOC_FAILED = 3,
  RET_INV_PATH = 4,
  RET_MATH_ERR = 5,
  RET_CANCEL = 6
}
enum  ENTITY_COLOR {
  DEFAULT_COLOR_WIRE,
  DEFAULT_COLOR_VIA_UP,
  DEFAULT_COLOR_VIA_DOWN,
  DEFAULT_COLOR_GRID,
  DEFAULT_COLOR_ANNOTATION,
  DEFAULT_COLOR_ANNOTATION_FRAME,
  DEFAULT_COLOR_GATE,
  DEFAULT_COLOR_GATE_FRAME,
  DEFAULT_COLOR_GATE_PORT,
  DEFAULT_COLOR_TEXT,
  DEFAULT_COLOR_EMARKER
}
enum  MAP_STORAGE_TYPE {
  MAP_STORAGE_TYPE_MEM = 0,
  MAP_STORAGE_TYPE_PERSISTENT_FILE = 1,
  MAP_STORAGE_TYPE_TEMP_FILE = 2
}
enum  IMAGE_TYPE {
  IMAGE_TYPE_GS_BYTE = 1,
  IMAGE_TYPE_GS_DOUBLE = 2,
  IMAGE_TYPE_RGBA = 3
}
enum  RC_SEVERITY {
  RC_UNDEFINED = 0,
  RC_ERROR = 1,
  RC_WARNING = 2
}
 An enum for several types of Rule Check problem types. More...

Functions

std::string get_temp_directory ()
 Get the temp directory.
template<typename IntegerType >
IntegerType next_power_of_two (IntegerType i)
 Calculate the next higher power of two for a value i with i > 0.
std::vector< std::string > tokenize (std::string const &str)
 Tokenize a string.
std::string write_string_to_temp_file (std::string const &dir, std::string const &content)
 Write a string to a temp file.
void write_string_to_file (std::string const &path, std::string const &content)
 Write a string to a file.
int execute_command (std::string const &command, std::list< std::string > const &params)
 Execute a command.
bool is_directory (std::string const &path)
 Check if a path is a directory.
bool is_file (std::string const &path)
 Check if a path is a regular file.
bool is_symlink (std::string const &path)
 Check if a path is a symlink.
bool file_exists (std::string const &path)
 Check if a file or directory exists.
std::string get_basedir (std::string const &path)
 Get the base directory for file or directory.
std::string get_realpath (std::string const &path)
 Get the canonicalized absolute pathname.
std::string get_file_suffix (std::string const &path)
 Get a file suffix without the dot, e.g.
std::string get_filename_from_path (std::string const &path)
 Get filename part of a path.
std::string get_basename (std::string const &path)
 Get the basename of a file.
void remove_file (std::string const &filename)
 Unlink a file.
void remove_directory (std::string const &path)
 Unlink a directory with all files in it.
void create_directory (std::string const &directory, mode_t mode=0700)
 Create a directory.
std::string create_temp_directory ()
 Create a temp directory.
std::string create_temp_directory (std::string const &directory_pattern)
 Create a temporary directory based on a path pattern specification.
std::string generate_temp_file_pattern (std::string const &basedir)
 Generate a pattern within a basedir for temp files.
std::list< std::string > read_directory (std::string const &path, bool prefix_path=false)
 Read all entries from a directory, but not from subdirectories.
std::string join_pathes (std::string const &base_path, std::string const &extension_path)
 Join path specifications.
std::string get_relative_path (std::string const &path, std::string const &relative_to)
 Make a path specification relative to another.
boost::filesystem::path strip_path (boost::filesystem::path const &strip_from, boost::filesystem::path const &strip_what)
 Strip the leading directory part from a path.
std::string gen_tabs (int n)
template<typename ImageType >
std::shared_ptr< ImageType > load_image (std::string const &path)
 Load an image in a common image format, such as tiff.
template<typename ImageType >
void load_image (std::string const &path, std::shared_ptr< ImageType > img)
 Load an image in a common image format, such as tiff, into an existing degate image.
template<typename ImageType >
void save_image (std::string const &path, std::shared_ptr< ImageType > img)
 Store an image in a common file format.
template<typename ImageType >
void save_part_of_image (std::string const &path, std::shared_ptr< ImageType > img, BoundingBox const &bounding_box)
 Save a part of an image.
template<typename ImageType >
void save_normalized_image (std::string const &path, std::shared_ptr< ImageType > img)
 Normalize a single channel image and store it in a common file format.
template<typename ImageType >
std::shared_ptr< ImageType > merge_images (std::list< std::shared_ptr< ImageType > > const &images)
 Merge a set of images by averaging them.
template<typename ImageType >
void flip_left_right (std::shared_ptr< ImageType > img)
 Flip image in place from left to right.
template<typename ImageType >
void flip_up_down (std::shared_ptr< ImageType > img)
 Flip image in place from top to down.
template<typename ImageType >
void flip_both (std::shared_ptr< ImageType > img)
 Flip image in place from top to down and from left to right.
double rgba_to_hue (rgba_pixel_t p)
 Convert an RGBA pixel to a hue value.
double rgba_to_saturation (rgba_pixel_t p)
 Convert an RGBA pixel to a saturation value.
double rgba_to_lightness (rgba_pixel_t p)
 Convert an RGBA pixel to a lightness value.
template<typename PixelTypeDst , typename PixelTypeSrc >
PixelTypeDst convert_pixel (PixelTypeSrc p)
 Convert a pixel from a source type to a destination type.
template<>
gs_byte_pixel_t convert_pixel< gs_byte_pixel_t, rgba_pixel_t > (rgba_pixel_t p)
 Convert pixel value from from rgba -> byte.
template<>
gs_double_pixel_t convert_pixel< gs_double_pixel_t, rgba_pixel_t > (rgba_pixel_t p)
 Convert pixel value from from rgba -> double.
template<>
rgba_pixel_t convert_pixel< rgba_pixel_t, gs_byte_pixel_t > (gs_byte_pixel_t p)
 Convert pixel value from from byte -> rgba.
template<>
rgba_pixel_t convert_pixel< rgba_pixel_t, gs_double_pixel_t > (gs_double_pixel_t p)
 Convert pixel value from from double -> rgba.
template<typename PixelTypeDst , typename ImageTypeSrc >
PixelTypeDst get_pixel_as (typename std::shared_ptr< ImageTypeSrc > img, unsigned int x, unsigned int y)
template<typename PixelTypeSrc , typename ImageTypeDst >
void set_pixel_as (typename std::shared_ptr< ImageTypeDst > img, unsigned int x, unsigned int y, PixelTypeSrc p)
template<typename ImageTypeDst , typename ImageTypeSrc >
void copy_image (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src)
 Copy an image.
template<typename ImageTypeDst , typename ImageTypeSrc >
void extract_partial_image (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, unsigned int min_x, unsigned int max_x, unsigned int min_y, unsigned int max_y)
 Extract a partial image from src with the region defined by the parameters into a destination image dst.
template<typename ImageTypeDst , typename ImageTypeSrc >
void extract_partial_image (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, BoundingBox const &bounding_box)
 Extract a partial image.
template<typename ImageTypeDst , typename ImageTypeSrc >
void convert_to_greyscale (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src)
 Convert an image to greyscale.
template<typename ImageType >
void convert_to_greyscale (std::shared_ptr< ImageType > img)
 In place conversion to a greyscale image.
template<typename ImageTypeDst , typename ImageTypeSrc >
void scale_down_by_2 (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src)
 Scale a source image down by factor 2.
template<typename ImageTypeDst , typename ImageTypeSrc >
void scale_down_by_power_of_2 (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src)
 Scale a source image down by factor 2.
template<typename ImageType >
void clear_image (std::shared_ptr< ImageType > img)
 Clear an image.
template<typename ImageType >
std::shared_ptr< ImageType > load_degate_image (unsigned int width, unsigned int height, std::string const &path)
 Helper function to load existing images in a degate image format.
template<typename ImageTypeDst , typename ImageTypeSrc >
void normalize (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, double lower_bound=0, double upper_bound=1)
 Normalize a single channel image.
template<typename ImageType >
void normalize (std::shared_ptr< ImageType > img, double lower_bound=0, double upper_bound=1)
 Normalize a single channel image in place.
template<typename ImageTypeDst , typename ImageTypeSrc >
void thresholding_image (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, double threshold)
 Thresholding a single channel image.
template<typename ImageTypeDst , typename ImageTypeSrc >
void convolve (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, FilterKernel_shptr kernel)
 Convolve a single channel source image with a filter kernel and write it into a destination image.
template<typename ImageTypeDst , typename ImageTypeSrc , typename FunctionPolicy >
void filter_image (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, unsigned int kernel_width=3, unsigned int threshold=3)
 Filter an (RBGA) image.
template<typename ImageType >
ImageType::pixel_type get_minimum (std::shared_ptr< ImageType > img)
 Get the minimum pixel value of a single channel image.
template<typename ImageType >
ImageType::pixel_type get_maximum (std::shared_ptr< ImageType > img)
 Get the maximum pixel value of a single channel image.
template<typename ImageType >
double average (std::shared_ptr< ImageType > img)
 Calculate the average pixel value of a single channel image.
template<typename ImageType >
double average (std::shared_ptr< ImageType > img, unsigned int start_x, unsigned int start_y, unsigned int width, unsigned int height)
 Calculate the average pixel value of a single channel image.
template<typename ImageType >
void average_and_stddev (std::shared_ptr< ImageType > img, unsigned int start_x, unsigned int start_y, unsigned int width, unsigned int height, double *avg, double *stddev)
 Calculate the average pixel value of a single channel image.
Layer_shptr get_first_layer (LogicModel_shptr lmodel, Layer::LAYER_TYPE layer_type)
 Get the first layer of a layer type.
Layer_shptr get_first_logic_layer (LogicModel_shptr lmodel)
 Get the first layer that is a logic layer.
Gate_shptr get_gate_by_name (LogicModel_shptr lmodel, std::string const &gate_name)
 Lookup a gate by it's name.
void apply_colors_to_gate_ports (LogicModel_shptr lmodel, PortColorManager_shptr pcm)
 Get the color definition for port names from the PortColorManager and apply it to gate ports.
std::list< Layer_shptrget_available_standard_layers (LogicModel_shptr lmodel)
 Get layer pointers for the first transistor layer and M1 and M2, if they are available.
template<typename ImageType >
std::shared_ptr< ImageType > grab_image (LogicModel_shptr lmodel, Layer_shptr layer, BoundingBox const &bounding_box)
 Extract a partial image from the background image for a layer.
void merge_gate_images (LogicModel_shptr lmodel, Layer_shptr layer, GateTemplate_shptr tmpl, std::list< Gate_shptr > const &gates)
 Merge images.
void merge_gate_images (LogicModel_shptr lmodel, ObjectSet gates)
 Merge images.
void grab_template_images (LogicModel_shptr lmodel, GateTemplate_shptr gate_template, BoundingBox const &bounding_box, Gate::ORIENTATION orientation=Gate::ORIENTATION_NORMAL)
 Extract a partial image from the background images for several layers and set the extracted images as master images for a gate template.
template<class InputIterator >
std::set< Net_shptrcollect_nets (InputIterator first, InputIterator last)
 Collect nets that are used by the objects from first to last.
template<class InputIterator >
void isolate_objects (LogicModel_shptr lmodel, InputIterator first, InputIterator last)
 Isolate objects.
void remove_entire_net (LogicModel_shptr lmodel, Net_shptr net)
 Remove net from the logic model and remove it from all objects, which share a net.
void connect_objects (LogicModel_shptr lmodel, ConnectedLogicModelObject_shptr o1, ConnectedLogicModelObject_shptr o2)
 Connect objects.
template<class InputIterator >
void connect_objects (LogicModel_shptr lmodel, InputIterator first, InputIterator last)
 Connect objects.
void autoconnect_objects (LogicModel_shptr lmodel, Layer_shptr layer, BoundingBox const &search_bbox)
 Autoconnect objects that tangent each other from a layer within the bounding box.
void autoconnect_interlayer_objects (LogicModel_shptr lmodel, Layer_shptr layer, BoundingBox const &search_bbox)
 Autoconnect vias on adjacent enabled layers.
void load_background_image (Layer_shptr layer, std::string const &project_dir, std::string const &image_file)
 Load an image in a common image format as background image for a layer.
void clear_logic_model (LogicModel_shptr lmodel, Layer_shptr layer)
 Clear the logic model for a layer.
Layer_shptr get_first_enabled_layer (LogicModel_shptr lmodel)
 Get first enabled layer

Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer for layer, then this exception is raised.

Layer_shptr get_next_enabled_layer (LogicModel_shptr lmodel)
 Get next enabled layer.
Layer_shptr get_next_enabled_layer (LogicModel_shptr lmodel, Layer_shptr layer)
 Get the next enabled layer, that is above layer.
Layer_shptr get_prev_enabled_layer (LogicModel_shptr lmodel)
 Get previous enabled layer.
Layer_shptr get_prev_enabled_layer (LogicModel_shptr lmodel, Layer_shptr layer)
 Get the previous enabled layer, that is below layer.
Layer_shptr get_current_layer (Project_shptr project)
 Get the current layer.
bool is_logic_class (Gate_shptr gate, std::string const &logic_class)
 Check if a gate is of a specific logic class.
GateTemplatePort::PORT_TYPE get_port_type (GatePort_shptr gate_port)
 Get the port type of a gate port.
std::string get_template_port_name (GatePort_shptr gate_port)
 Get the name of a corresponding template port.
void apply_port_color_settings (LogicModel_shptr lmodel, PortColorManager_shptr pcm)
 Apply port color definitions to all gate template ports.
void update_port_diameters (LogicModel_shptr lmodel, diameter_t new_size)
 Resize all gate ports from the logic model to the new size.
template<typename ImageTypeDst , typename ImageTypeSrc >
void median_filter (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, unsigned int kernel_width=3)
 Filter an image with a median filter.
void determine_module_ports_for_root (LogicModel_shptr lmodel)
 Determine ports of a root module.
template<typename ImageTypeDst , typename ImageTypeSrc >
void erode_image (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, unsigned int kernel_width=3, unsigned int erosion_threshold=3)
 Filter an image with an erosion filter.
template<typename ImageTypeDst , typename ImageTypeSrc >
void dilate_image (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, unsigned int kernel_width=3, unsigned int dilation_threshold=3)
 Filter an image with an erosion filter.
template<typename ImageTypeDst , typename ImageTypeSrc >
void morphological_open (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, unsigned int kernel_width=3, unsigned int threshold_dilate=1, unsigned int threshold_erode=3)
 Morphological open.
template<typename ImageTypeDst , typename ImageTypeSrc >
void morphological_close (std::shared_ptr< ImageTypeDst > dst, std::shared_ptr< ImageTypeSrc > src, unsigned int kernel_width=3, unsigned int threshold_dilate=1, unsigned int threshold_erode=3)
 Morphological close.
template<typename ImageType >
bool zhang_suen_thinning_iteration (std::shared_ptr< ImageType > img, bool condition_switch)
 Helper function for the Zhang-Suen-Thinning.
template<typename ImageType >
void thinning (std::shared_ptr< ImageType > img)
 Zhang-Suen-Thinning of an image.
bool is_removable (PlacedLogicModelObject_shptr o)
 Returns true if the object can be removed from the Logic Model.
bool is_interconnectable (PlacedLogicModelObject_shptr o)
 Check if an object can be electrically interconnected with another object.
template<typename Type >
bool is_of_object_type (PlacedLogicModelObject_shptr o)
template<typename T >
median (std::vector< T > &v)
 Calculate the median of a vector.
template<typename T >
average (std::vector< T > const &v)
 Calculate the average of a vector.
template<typename T >
standard_deviation (std::vector< T > const &v)
 Calculate the standard deviation of a vector.
bool check_object_tangency (PlacedLogicModelObject_shptr o1, PlacedLogicModelObject_shptr o2)
 Check if two objects are tangent.
bool check_object_tangency (Circle_shptr o1, Circle_shptr o2)
bool check_object_tangency (Line_shptr o1, Line_shptr o2)
bool check_object_tangency (Rectangle_shptr o1, Rectangle_shptr o2)
bool check_object_tangency (Circle_shptr o1, Line_shptr o2)
bool check_object_tangency (Circle_shptr o1, Rectangle_shptr o2)
bool check_object_tangency (Line_shptr l, Rectangle_shptr r)
template<class T >
void ignore_unused_variable_warning (T const &)
 A dummy method to get rid of compiler warnings.
xmlrpc_c::value remote_method_call (std::string const &server_url, std::string const &method_name, xmlrpc_c::paramList const &params)
 Convinience method to call remote methods.
void push_changes_to_server (std::string const &server_url, LogicModel_shptr lmodel)
 Push objects from the logic model to a remote server.
transaction_id_t pull_changes_from_server (std::string const &server_url, LogicModel_shptr lmodel, transaction_id_t start_tid)
 Pull objects from a remote server into the logic model.
void process_changelog_command (LogicModel_shptr lmodel, transaction_id_t transaction_id, std::vector< xmlrpc_c::value > const &command)
 Parse an execute a command.

Detailed Description

The namespace 'degate' is the namespace for everything that belongs to libdegate.


Typedef Documentation

typedef std::shared_ptr<Annotation> degate::Annotation_shptr

Definition at line 128 of file globals.h.

Definition at line 279 of file Image.h.

Definition at line 280 of file Image.h.

typedef std::shared_ptr<const DeepCopyable> degate::c_DeepCopyable_shptr

Definition at line 31 of file DeepCopyable.h.

typedef std::shared_ptr<Circle> degate::Circle_shptr

Definition at line 84 of file globals.h.

Definition at line 54 of file BackgroundClassifier.h.

Definition at line 122 of file CodeTemplateGenerator.h.

typedef uint32_t degate::color_t

defines the type for colors

Definition at line 142 of file globals.h.

Definition at line 93 of file globals.h.

typedef std::list<coord_type> degate::coord_list

Definition at line 42 of file BackgroundClassifier.h.

typedef std::pair<unsigned int, unsigned int> degate::coord_type

Definition at line 41 of file BackgroundClassifier.h.

typedef std::shared_ptr<DeepCopyable> degate::DeepCopyable_shptr

Definition at line 29 of file DeepCopyable.h.

Definition at line 169 of file globals.h.

typedef unsigned int degate::diameter_t

Definition at line 147 of file globals.h.

typedef std::shared_ptr<EMarker> degate::EMarker_shptr

Definition at line 125 of file globals.h.

Definition at line 103 of file ExternalMatching.h.

typedef std::list<std::string> degate::file_format_collection

Definition at line 39 of file ImageReaderFactory.h.

typedef std::shared_ptr<FilterKernel> degate::FilterKernel_shptr

Definition at line 90 of file FilterKernel.h.

typedef std::shared_ptr<Gate> degate::Gate_shptr

Definition at line 329 of file Gate.h.

typedef std::shared_ptr<GateLibrary> degate::GateLibrary_shptr

Definition at line 113 of file globals.h.

typedef std::shared_ptr<GatePort> degate::GatePort_shptr

Definition at line 107 of file globals.h.

typedef std::shared_ptr<GateTemplate> degate::GateTemplate_shptr

Definition at line 110 of file globals.h.

Definition at line 311 of file Image.h.

Definition at line 312 of file Image.h.

Definition at line 205 of file GateTemplatePort.h.

typedef std::shared_ptr<Grid> degate::Grid_shptr

Definition at line 131 of file Grid.h.

typedef uint8_t degate::gs_byte_pixel_t

Definition at line 36 of file PixelPolicies.h.

typedef double degate::gs_double_pixel_t

Definition at line 37 of file PixelPolicies.h.

typedef std::shared_ptr<ImageBase> degate::ImageBase_shptr

Definition at line 153 of file Image.h.

Definition at line 117 of file ImageProcessorBase.h.

typedef std::shared_ptr<IrregularGrid> degate::IrregularGrid_shptr

Definition at line 88 of file IrregularGrid.h.

typedef unsigned long long degate::layer_id_t

Definition at line 145 of file globals.h.

typedef unsigned int degate::layer_position_t

Definition at line 138 of file globals.h.

typedef std::shared_ptr<Layer> degate::Layer_shptr

Definition at line 116 of file globals.h.

typedef unsigned int degate::length_t

Definition at line 148 of file globals.h.

typedef std::shared_ptr<Line> degate::Line_shptr

Definition at line 87 of file globals.h.

Definition at line 43 of file LineSegmentExtraction.h.

typedef std::shared_ptr<LineSegment> degate::LineSegment_shptr

Definition at line 47 of file LineSegmentExtraction.h.

typedef std::shared_ptr<LineSegmentMap> degate::LineSegmentMap_shptr

Definition at line 265 of file LineSegmentExtraction.h.

typedef std::shared_ptr<LoG> degate::LoG_shptr

Definition at line 204 of file FilterKernel.h.

typedef std::shared_ptr<LogicModel> degate::LogicModel_shptr

Definition at line 135 of file globals.h.

Definition at line 151 of file LogicModelObjectBase.h.

Definition at line 296 of file Image.h.

Definition at line 300 of file Image.h.

Definition at line 303 of file Image.h.

Definition at line 301 of file Image.h.

Definition at line 304 of file Image.h.

Definition at line 302 of file Image.h.

typedef std::shared_ptr< MemoryImage_RGBA > degate::MemoryImage_shptr

Definition at line 297 of file Image.h.

typedef std::shared_ptr<Module> degate::Module_shptr

Definition at line 131 of file globals.h.

typedef std::shared_ptr<Net> degate::Net_shptr

Definition at line 102 of file globals.h.

typedef unsigned long long degate::object_id_t

Definition at line 144 of file globals.h.

Definition at line 87 of file ObjectIDRewriter.h.

Definition at line 292 of file Image.h.

Definition at line 293 of file Image.h.

Definition at line 96 of file globals.h.

typedef std::shared_ptr<Point> degate::Point_shptr

Definition at line 60 of file Point.h.

Typedef for a shared pointer on PortColorManager objects.

Definition at line 129 of file PortColorManager.h.

typedef int degate::pos_t

Definition at line 149 of file globals.h.

Definition at line 212 of file ProgressControl.h.

typedef std::shared_ptr<Project> degate::Project_shptr

Definition at line 44 of file Project.h.

typedef std::list<std::shared_ptr<Project> > degate::ProjectList

Definition at line 42 of file Project.h.

Definition at line 56 of file Project.h.

typedef std::shared_ptr<RCBase> degate::RCBase_shptr

Definition at line 126 of file RCBase.h.

typedef std::shared_ptr<RCViolation> degate::RCViolation_shptr

Definition at line 33 of file RCVContainer.h.

typedef std::shared_ptr<Rectangle> degate::Rectangle_shptr

Definition at line 90 of file globals.h.

typedef std::shared_ptr<RegularGrid> degate::RegularGrid_shptr

Definition at line 78 of file RegularGrid.h.

typedef std::shared_ptr<RemoteObject> degate::RemoteObject_shptr

Definition at line 99 of file globals.h.

Definition at line 307 of file Image.h.

Definition at line 308 of file Image.h.

typedef uint32_t degate::rgba_pixel_t

Definition at line 38 of file PixelPolicies.h.

A typedef for scaling managers that handle background images.

Definition at line 197 of file ScalingManager.h.

typedef std::shared_ptr<SobelOperator> degate::SobelOperator_shptr

Definition at line 151 of file FilterKernel.h.

typedef std::shared_ptr<SobelXOperator> degate::SobelXOperator_shptr

Definition at line 110 of file FilterKernel.h.

typedef std::shared_ptr<SobelYOperator> degate::SobelYOperator_shptr

Definition at line 130 of file FilterKernel.h.

Definition at line 66 of file SubProjectAnnotation.h.

Definition at line 285 of file Image.h.

Definition at line 289 of file Image.h.

Definition at line 284 of file Image.h.

Definition at line 288 of file Image.h.

Definition at line 283 of file Image.h.

typedef std::shared_ptr<TempImage_RGBA> degate::TempImage_RGBA_shptr

Definition at line 287 of file Image.h.

Definition at line 337 of file TemplateMatching.h.

Definition at line 412 of file TemplateMatching.h.

Definition at line 395 of file TemplateMatching.h.

Definition at line 353 of file TemplateMatching.h.

Definition at line 272 of file Image.h.

Definition at line 276 of file Image.h.

Definition at line 271 of file Image.h.

Definition at line 275 of file Image.h.

Typedefs for common types of virtual images.

Definition at line 270 of file Image.h.

typedef std::shared_ptr<TileImage_RGBA> degate::TileImage_RGBA_shptr

Definition at line 274 of file Image.h.

typedef unsigned long long degate::transaction_id_t

Definition at line 146 of file globals.h.

Definition at line 85 of file VerilogCodeTemplateGenerator.h.

Definition at line 57 of file VerilogTBCodeTemplateGenerator.h.

Definition at line 92 of file VHDLCodeTemplateGenerator.h.

Definition at line 63 of file VHDLTBCodeTemplateGenerator.h.

typedef std::shared_ptr<Via> degate::Via_shptr

Definition at line 122 of file globals.h.

typedef std::shared_ptr<ViaMatching> degate::ViaMatching_shptr

Definition at line 91 of file ViaMatching.h.

typedef std::shared_ptr<Wire> degate::Wire_shptr

Definition at line 119 of file globals.h.

typedef std::shared_ptr<WireMatching> degate::WireMatching_shptr

Definition at line 62 of file WireMatching.h.


Enumeration Type Documentation

Enumerator:
DEFAULT_COLOR_WIRE 
DEFAULT_COLOR_VIA_UP 
DEFAULT_COLOR_VIA_DOWN 
DEFAULT_COLOR_GRID 
DEFAULT_COLOR_ANNOTATION 
DEFAULT_COLOR_ANNOTATION_FRAME 
DEFAULT_COLOR_GATE 
DEFAULT_COLOR_GATE_FRAME 
DEFAULT_COLOR_GATE_PORT 
DEFAULT_COLOR_TEXT 
DEFAULT_COLOR_EMARKER 

Definition at line 155 of file globals.h.

Enumerator:
IMAGE_TYPE_GS_BYTE 
IMAGE_TYPE_GS_DOUBLE 
IMAGE_TYPE_RGBA 

Definition at line 30 of file PixelPolicies.h.

Enumerator:
MAP_STORAGE_TYPE_MEM 
MAP_STORAGE_TYPE_PERSISTENT_FILE 
MAP_STORAGE_TYPE_TEMP_FILE 

Definition at line 45 of file MemoryMap.h.

An enum for several types of Rule Check problem types.

Enumerator:
RC_UNDEFINED 
RC_ERROR 
RC_WARNING 

Definition at line 36 of file RCBase.h.

                   {
    RC_UNDEFINED = 0,
    RC_ERROR = 1,
    RC_WARNING = 2
  };
Enumerator:
RET_OK 
RET_ERR 
RET_INV_PTR 
RET_MALLOC_FAILED 
RET_INV_PATH 
RET_MATH_ERR 
RET_CANCEL 

Definition at line 42 of file globals.h.


Function Documentation

Get the color definition for port names from the PortColorManager and apply it to gate ports.

Definition at line 78 of file LogicModelHelper.cc.

                                                                    {

  // iterate over gates
  for(LogicModel::gate_collection::iterator iter = lmodel->gates_begin();
      iter != lmodel->gates_end(); ++iter) {
    Gate_shptr gate = (*iter).second;

    // iterate over gate ports
    for(Gate::port_iterator iter = gate->ports_begin();
        iter != gate->ports_end(); ++iter) {

      GatePort_shptr gate_port = *iter;

      if(gate_port->has_template_port()) {
        GateTemplatePort_shptr tmpl_port = gate_port->get_template_port();
        std::string port_name = tmpl_port->get_name();
        if(pcm->has_color_definition(port_name)) {
          color_t fill_c = pcm->get_fill_color(port_name);
          color_t frame_c = pcm->get_frame_color(port_name);

          gate_port->set_fill_color(fill_c);
          gate_port->set_frame_color(frame_c);
        }
      }
    }
  }
}

Apply port color definitions to all gate template ports.

Definition at line 386 of file LogicModelHelper.cc.

                                                                                          {
  if(lmodel == NULL || pcm == NULL)
    throw InvalidPointerException("Invalid parameter for apply_port_color_settings()");

  // iterate over gates

  for(LogicModel::gate_collection::iterator gate_iter = lmodel->gates_begin();
      gate_iter != lmodel->gates_end(); ++gate_iter) {
    Gate_shptr gate = gate_iter->second;

    // iterate over ports

    for(Gate::port_iterator iter = gate->ports_begin(); iter != gate->ports_end(); ++iter) {
      GatePort_shptr port = *iter;

      if(port->has_template_port()) {
        GateTemplatePort_shptr tmpl_port = port->get_template_port();

        std::string port_name = tmpl_port->get_name();
        if(pcm->has_color_definition(port_name)) {
          tmpl_port->set_frame_color(pcm->get_frame_color(port_name));
          tmpl_port->set_fill_color(pcm->get_fill_color(port_name));
        }

      }
    }

  }

}
void degate::autoconnect_interlayer_objects ( LogicModel_shptr  lmodel,
Layer_shptr  layer,
BoundingBox const &  search_bbox 
)

Autoconnect vias on adjacent enabled layers.

Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer for the logic model, then this exception is raised.

Definition at line 615 of file LogicModelHelper.cc.

References autoconnect_interlayer_objects_via_gport(), autoconnect_interlayer_objects_via_via(), degate::Via::DIRECTION_DOWN, degate::Via::DIRECTION_UP, degate::BoundingBox::get_bounding_box(), get_next_enabled_layer(), and get_prev_enabled_layer().

                                                                            {
  if(lmodel == NULL || layer == NULL)
    throw InvalidPointerException("You passed an invalid shared pointer.");

  Layer_shptr
    layer_above = get_next_enabled_layer(lmodel, layer),
    layer_below = get_prev_enabled_layer(lmodel, layer);

  Via_shptr v1;

  // iterate over objects
  for(Layer::qt_region_iterator iter = layer->region_begin(search_bbox);
      iter != layer->region_end(); ++iter) {

    if((v1 = std::dynamic_pointer_cast<Via>(*iter)) != NULL) {

      BoundingBox const& bb = v1->get_bounding_box();

      /* Iterate over vias one layer above and one layer below
         in the region identified by bounding box bb. */

      if(layer_above != NULL)
        autoconnect_interlayer_objects_via_via(lmodel, layer_above, bb, v1,
                                               Via::DIRECTION_UP, Via::DIRECTION_DOWN);

      if(layer_below != NULL) {
        autoconnect_interlayer_objects_via_via(lmodel, layer_below, bb, v1,
                                               Via::DIRECTION_DOWN, Via::DIRECTION_UP);
        autoconnect_interlayer_objects_via_gport(lmodel, layer_below, bb, v1,
                                                 Via::DIRECTION_DOWN);
      }

    }
  }

}

Here is the call graph for this function:

void degate::autoconnect_objects ( LogicModel_shptr  lmodel,
Layer_shptr  layer,
BoundingBox const &  search_bbox 
)

Autoconnect objects that tangent each other from a layer within the bounding box.

Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer for the logic model, then this exception is raised.
See also:
connnect_objects()

Definition at line 520 of file LogicModelHelper.cc.

References check_object_tangency(), connect_objects(), and degate::BoundingBox::get_bounding_box().

                                                                 {

  if(lmodel == NULL || layer == NULL)
    throw InvalidPointerException("You passed an invalid shared pointer.");

  // iterate over connectable objects
  for(Layer::qt_region_iterator iter = layer->region_begin(search_bbox);
      iter != layer->region_end(); ++iter) {

    ConnectedLogicModelObject_shptr clmo1;

    if((clmo1 = std::dynamic_pointer_cast<ConnectedLogicModelObject>(*iter)) != NULL) {

      BoundingBox const& bb = clmo1->get_bounding_box();

      /* Iterate over connectable objects in the region identified
         by bounding box bb.
      */
      for(Layer::qt_region_iterator siter = layer->region_begin(bb);
          siter != layer->region_end(); ++siter) {

        ConnectedLogicModelObject_shptr clmo2;
        if((clmo2 =
            std::dynamic_pointer_cast<ConnectedLogicModelObject>(*siter)) != NULL) {

          if((clmo1->get_net() == NULL ||
              clmo2->get_net() == NULL ||
              clmo1->get_net() != clmo2->get_net()) && // excludes identical objects, too
             check_object_tangency(std::dynamic_pointer_cast<PlacedLogicModelObject>(clmo1),
                                   std::dynamic_pointer_cast<PlacedLogicModelObject>(clmo2)))

            connect_objects(lmodel, clmo1, clmo2);


        }
      }
    }
  }
}

Here is the call graph for this function:

template<typename T >
T degate::average ( std::vector< T > const &  v) [inline]

Calculate the average of a vector.

Exceptions:
DegateRuntimeExceptionThis exception is thrown if vector's size is 0.

Definition at line 59 of file Statistics.h.

                                          {

    if(v.empty())
      throw DegateRuntimeException("Error in average(): The vector is empty.");

    double _sum = 0;

    for(typename std::vector<T>::const_iterator iter = v.begin();
        iter != v.end(); ++iter)
      _sum += *iter;

    return _sum / (double)v.size();
  }
template<typename ImageType >
double degate::average ( std::shared_ptr< ImageType >  img)

Calculate the average pixel value of a single channel image.

If the input image is a multi-channel image, data will be converted on-the-fly.

Definition at line 75 of file ImageStatistics.h.

Referenced by degate::TemplateMatching::subtract_mean().

                                               {
    return average(img, 0, 0, img->get_width(), img->get_height());
  }

Here is the caller graph for this function:

template<typename ImageType >
double degate::average ( std::shared_ptr< ImageType >  img,
unsigned int  start_x,
unsigned int  start_y,
unsigned int  width,
unsigned int  height 
)

Calculate the average pixel value of a single channel image.

If the input image is a multi-channel image, data will be converted on-the-fly.

Exceptions:
DegateRuntimeExceptionThis exception is thrown, if the image area is 0.

Definition at line 85 of file ImageStatistics.h.

                                                          {

    double sum = 0;

    if(height == 0 || width == 0) throw DegateRuntimeException("Can't calculate average for an image.");

    for(unsigned int y = start_y; y < height; y++)
      for(unsigned int x = start_x; x < width; x++) {
        sum += img->template get_pixel_as<double>(x, y);
      }

    return sum / (double)(height * width);
  }
template<typename ImageType >
void degate::average_and_stddev ( std::shared_ptr< ImageType >  img,
unsigned int  start_x,
unsigned int  start_y,
unsigned int  width,
unsigned int  height,
double *  avg,
double *  stddev 
)

Calculate the average pixel value of a single channel image.

If the input image is a multi-channel image, data will be converted on-the-fly.

Exceptions:
DegateRuntimeExceptionThis exception is thrown, if the image area is 0.

Definition at line 107 of file ImageStatistics.h.

Referenced by degate::ViaMatching::scan().

                                                         {

    double sum = 0;
    
    if(height == 0 || width == 0)
      throw DegateRuntimeException("Can't calculate average for an image.");
    
    for(unsigned int y = start_y; y < start_y + height; y++)
      for(unsigned int x = start_x; x < start_x + width; x++) {
        sum += img->template get_pixel_as<gs_double_pixel_t>(x, y);
      }
    
    *avg = sum / (double)(height * width);
    
    sum = 0;
    
    for(unsigned int y = start_y; y < start_y + height; y++)
      for(unsigned int x = start_x; x < start_x + width; x++) {
        sum += pow(*avg - img->template get_pixel_as<gs_double_pixel_t>(x, y), 2);
      }
    
    *stddev = sqrt(sum/(double)(height * width));
  }

Here is the caller graph for this function:

bool degate::check_object_tangency ( PlacedLogicModelObject_shptr  o1,
PlacedLogicModelObject_shptr  o2 
)

Check if two objects are tangent.

It is assumed that both objects are on the same layer.

Returns:
Returns whether the objects are touching each other.

Definition at line 199 of file TangencyCheck.cc.

Referenced by autoconnect_interlayer_objects_via_gport(), autoconnect_interlayer_objects_via_via(), autoconnect_objects(), and check_object_tangency().

                                                                    {
  if(o1 == NULL || o2 == NULL)
    throw InvalidPointerException("You passed an invalid shared pointer.");

  if(!o1->get_bounding_box().intersects(o2->get_bounding_box()))
    return false;

  Circle_shptr c1, c2;
  Line_shptr l1, l2;
  Rectangle_shptr r1, r2;

  c1 = std::dynamic_pointer_cast<Circle>(o1);
  l1 = std::dynamic_pointer_cast<Line>(o1);
  r1 = std::dynamic_pointer_cast<Rectangle>(o1);
  c2 = std::dynamic_pointer_cast<Circle>(o2);
  l2 = std::dynamic_pointer_cast<Line>(o2);
  r2 = std::dynamic_pointer_cast<Rectangle>(o2);

  if(c1 && c2)
    return check_object_tangency(c1, c2);
  else if(l1 && l2) {

    bool ret= check_object_tangency(l1, l2);
    std::cout << "Check l1/l2: " << ret << std::endl;
    return ret;
  }
  else if(r1 && r2)
    return check_object_tangency(r1, r2);

  else if(c1 && l2)
    return check_object_tangency(c1, l2);
  else if(l1 && c2)
    return check_object_tangency(c2, l1);

  else if(c1 && r2)
    return check_object_tangency(c1, r2);
  else if(r1 && c2)
    return check_object_tangency(c2, r1);


  else if(l1 && r2)
    return check_object_tangency(l1, r2);
  else if(r1 && l2)
    return check_object_tangency(l2, r1);

  assert(1==0);
}

Here is the caller graph for this function:

bool degate::check_object_tangency ( Circle_shptr  o1,
Circle_shptr  o2 
)

Definition at line 46 of file TangencyCheck.cc.

                                                    {

  int dx = o1->get_x() - o1->get_x();
  int dy = o2->get_y() - o1->get_y();
  return (sqrt(dx*dx + dy*dy) <= (o1->get_diameter() + o2->get_diameter()) / 2.0);
}
bool degate::check_object_tangency ( Line_shptr  o1,
Line_shptr  o2 
)

Definition at line 54 of file TangencyCheck.cc.

References degate::BoundingBox::get_bounding_box(), get_line_function_for_wire(), degate::BoundingBox::get_max_x(), degate::BoundingBox::get_max_y(), degate::BoundingBox::get_min_x(), and degate::BoundingBox::get_min_y().

                                                  {
  double m1, n1, m2, n2;
  bool ret1 = get_line_function_for_wire(o1, &m1, &n1);
  bool ret2 = get_line_function_for_wire(o2, &m2, &n2);

  if(ret1 && ret2) {

    double xi = - (n1 - n2) / (m1 - m2);
    double yi = n1 + m1 * xi;

    return( (o1->get_from_x() - xi)*(xi - o1->get_to_x()) >= 0 &&
            (o2->get_from_x() - xi)*(xi - o2->get_to_x()) >= 0 &&
            (o1->get_from_y() - yi)*(yi - o1->get_to_y()) >= 0 &&
            (o2->get_from_y() - yi)*(yi - o2->get_to_y()) >= 0);
  }
  else if(!ret1 && !ret2) {
    return o1->get_from_x() == o2->get_from_x();
  }
  else {
    Line_shptr v = ret1 ? o2 : o1;
    Line_shptr l = ret1 ? o1 : o2;

    BoundingBox const & b = v->get_bounding_box();

    if((l->get_from_x() > b.get_max_x() &&
        l->get_to_x()   > b.get_max_x()) ||
       // no intersection (line is to right of rectangle).

       (l->get_from_x() > b.get_min_x() &&
        l->get_to_x()   > b.get_min_x()) ||
       // no intersection (line is to left of rectangle).

       (l->get_from_y() > b.get_min_y() &&
        l->get_to_y()   > b.get_min_y()) ||
       // no intersection (line is above rectangle).

       (l->get_from_y() > b.get_max_y() &&
        l->get_to_y()   > b.get_max_y())
       //no intersection (line is below rectangle).
       )
      return false;
    else
      return true;

  }

  return false;
}

Here is the call graph for this function:

bool degate::check_object_tangency ( Rectangle_shptr  o1,
Rectangle_shptr  o2 
)

Definition at line 104 of file TangencyCheck.cc.

                                                       {
  return o1->get_bounding_box().intersects(o2->get_bounding_box());
}
bool degate::check_object_tangency ( Circle_shptr  o1,
Line_shptr  o2 
)

Definition at line 109 of file TangencyCheck.cc.

References check_object_tangency(), degate::BoundingBox::get_bounding_box(), degate::BoundingBox::get_max_x(), degate::BoundingBox::get_max_y(), degate::BoundingBox::get_min_x(), and degate::BoundingBox::get_min_y().

                                                  {
  BoundingBox const & b = o1->get_bounding_box();

  Rectangle_shptr r(new Rectangle(b.get_min_x(), b.get_max_x(),
                                  b.get_min_y(), b.get_max_y()));

  return check_object_tangency(o2, r);
}

Here is the call graph for this function:

bool degate::check_object_tangency ( Circle_shptr  o1,
Rectangle_shptr  o2 
)

Definition at line 119 of file TangencyCheck.cc.

                                                       {
  return o1->get_bounding_box().intersects(o2->get_bounding_box());
}
bool degate::check_object_tangency ( Line_shptr  l,
Rectangle_shptr  r 
)

Definition at line 124 of file TangencyCheck.cc.

                                                      {


  // http://stackoverflow.com/questions/99353/how-to-test-if-a-line-segment-intersects-an-axis-aligned-rectange-in-2d

  // Let the segment endpoints be p1=(x1 y1) and p2=(x2 y2).
  // Let the rectangle's corners be (xBL yBL) and (xTR yTR).

  int x1, x2, y1, y2;

  if(l->get_from_x() < l->get_to_x()) {
    x1 = l->get_from_x();
    y1 = l->get_from_y();
    x2 = l->get_to_x();
    y2 = l->get_to_y();
  }
  else {
    x2 = l->get_from_x();
    y2 = l->get_from_y();
    x1 = l->get_to_x();
    y1 = l->get_to_y();
  }

  // F(x y) = (y2-y1)x + (x1-x2)y + (x2*y1-x1*y2)

  int dy = y2 - y1;
  int dx = x1 - x2;
  int i = x2 * y1 - x1 * y2;

  // Calculate F(x,y) for each corner of the rectangle.
  // If any of the values f[i] is 0, the corner is on the line.
  int f1 = dy * r->get_min_x() + dx * r->get_min_y() + i;
  if(f1 == 0) return true;
  int f2 = dy * r->get_min_x() + dx * r->get_max_y() + i;
  if(f2 == 0) return true;
  int f3 = dy * r->get_max_x() + dx * r->get_min_y() + i;
  if(f3 == 0) return true;
  int f4 = dy * r->get_max_x() + dx * r->get_max_y() + i;
  if(f4 == 0) return true;

  /* If all corners are "below" or "above" the line, the
     objects can't intersect. */
  if((f1 < 0 && f2 < 0 && f3 < 0 && f4 < 0) ||
     (f1 > 0 && f2 > 0 && f3 > 0 && f4 > 0)) {
    return false;
  }

  /*
    Project the endpoint onto the x axis, and check if the
    segment's shadow intersects the polygon's shadow. Repeat on the y axis:
  */
  if( (x1 > r->get_max_x() &&
       x2 > r->get_max_x()) &&
      // no intersection (line is to right of rectangle).

      !(x1 > r->get_min_x() &&
        x2 > r->get_min_x()) &&
      // no intersection (line is to left of rectangle).

      !(y1 > r->get_max_y() &&
        y2 > r->get_max_y()) &&
      // no intersection (line is above rectangle).

      !(y1 < r->get_min_y() &&
        y2 < r->get_min_y())
      //no intersection (line is below rectangle).
      ) {
    return false;
  }

  else // there is an intersection
    return true;
}
template<typename ImageType >
void degate::clear_image ( std::shared_ptr< ImageType >  img)

Clear an image.

Definition at line 405 of file ImageManipulation.h.

                                                 {

    for(unsigned int y = 0; y < img->get_height(); y++)
      for(unsigned int x = 0; x < img->get_width(); x++)
        img->set_pixel(x, y, 0);
  }

Clear the logic model for a layer.

Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer for lmodel or layer, then this exception is raised.

Definition at line 216 of file LogicModelHelper.cc.

                                                                         {
  if(lmodel == NULL || layer == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to clear_logc_model()");

  // iterate over all objects that are placed on a specific layer and remove them

  for(LogicModel::object_collection::iterator iter = lmodel->objects_begin();
      iter != lmodel->objects_end(); ++iter) {
    PlacedLogicModelObject_shptr lmo = (*iter).second;
    if(lmo->get_layer() == layer) {
      lmodel->remove_object(lmo);
    }
  }

}
template<class InputIterator >
std::set<Net_shptr> degate::collect_nets ( InputIterator  first,
InputIterator  last 
)

Collect nets that are used by the objects from first to last.

Exceptions:
DegateRuntimeExceptionThis exception is thrown if one of the objects is not of type ConnectedLogicModelObject. This means that the object cannot be connected with anything.

Definition at line 146 of file LogicModelHelper.h.

                                                                          {

    std::set<Net_shptr> nets;

    for(InputIterator it = first; it != last; ++it) {
      ConnectedLogicModelObject_shptr clo =
        std::dynamic_pointer_cast<ConnectedLogicModelObject>(*it);

      if(clo == NULL) {
        throw DegateRuntimeException("Error in collect_nets(). One of the objects "
                                     "cannot be connected with anything.");
      }
      else {
        Net_shptr net = clo->get_net();
        if(net != NULL) nets.insert(net);
      }

    }
    return nets;
  }

Connect objects.

Definition at line 509 of file LogicModelHelper.cc.

Referenced by autoconnect_interlayer_objects_via_gport(), autoconnect_interlayer_objects_via_via(), and autoconnect_objects().

                                                                 {

  std::list<ConnectedLogicModelObject_shptr> v;
  v.push_back(o1);
  v.push_back(o2);
  connect_objects(lmodel, v.begin(), v.end());
}

Here is the caller graph for this function:

template<class InputIterator >
void degate::connect_objects ( LogicModel_shptr  lmodel,
InputIterator  first,
InputIterator  last 
)

Connect objects.

Unused nets are removed from the logic model.

Exceptions:
DegateRuntimeExceptionThis exception is thrown if one of the objects is not of type ConnectedLogicModelObject. This means that the object cannot be connected with anything.
InvalidPointerExceptionIf you pass an invalid shared pointer for the logic model, then this exception is raised.
See also:
connect_objects()
autoconnect_objects()

Definition at line 243 of file LogicModelHelper.h.

                                                                                         {

    if(lmodel == NULL)
      throw InvalidPointerException("You passed an invalid shared pointer for lmodel");


    std::set<Net_shptr> nets;
    try {
      nets = collect_nets<InputIterator>(first, last);
    }
    catch(DegateRuntimeException const& ex) {
      throw;
    }


    // collect objects we want to join
    std::set<ConnectedLogicModelObject_shptr> objects;

    for(InputIterator it = first; it != last; ++it) {
      objects.insert(std::dynamic_pointer_cast<ConnectedLogicModelObject>(*it));
    }

    for(std::set<Net_shptr>::iterator iter = nets.begin(); iter != nets.end(); ++iter) {

      Net_shptr net = *iter;

      for(Net::connection_iterator ci = net->begin(); ci != net->end(); ++ci) {
        PlacedLogicModelObject_shptr plo = lmodel->get_object(*ci);

        ConnectedLogicModelObject_shptr clo =
          std::dynamic_pointer_cast<ConnectedLogicModelObject>(plo);

        assert(clo != NULL);
        objects.insert(clo);
      }
    }


    Net_shptr new_net(new Net());

    // set new net
    for(std::set<ConnectedLogicModelObject_shptr>::iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
      ConnectedLogicModelObject_shptr clo = *iter;
      clo->set_net(new_net);
    }


    // remove nets from the logic model
    for(std::set<Net_shptr>::iterator iter = nets.begin(); iter != nets.end(); ++iter) {
      assert((*iter)->size() == 0);
      lmodel->remove_net(*iter);
    }

    lmodel->add_net(new_net);
  }
template<typename PixelTypeDst , typename PixelTypeSrc >
PixelTypeDst degate::convert_pixel ( PixelTypeSrc  p) [inline]

Convert a pixel from a source type to a destination type.

The default implementation will just make a copy of the pixel.

Definition at line 136 of file ImageManipulation.h.

                                                    {
    return p;
  }
template<>
gs_byte_pixel_t degate::convert_pixel< gs_byte_pixel_t, rgba_pixel_t > ( rgba_pixel_t  p) [inline]

Convert pixel value from from rgba -> byte.

Definition at line 145 of file ImageManipulation.h.

References RGBA_TO_GS_BY_VAL.

                                                                                      {
    return RGBA_TO_GS_BY_VAL(p);
  }
template<>
gs_double_pixel_t degate::convert_pixel< gs_double_pixel_t, rgba_pixel_t > ( rgba_pixel_t  p) [inline]

Convert pixel value from from rgba -> double.

Definition at line 153 of file ImageManipulation.h.

References RGBA_TO_GS_BY_VAL.

                                                                                          {
    return RGBA_TO_GS_BY_VAL(p);
  }
template<>
rgba_pixel_t degate::convert_pixel< rgba_pixel_t, gs_byte_pixel_t > ( gs_byte_pixel_t  p) [inline]

Convert pixel value from from byte -> rgba.

Definition at line 163 of file ImageManipulation.h.

References MERGE_CHANNELS.

                                                                                      {
    return MERGE_CHANNELS(p, p, p, 255);
  }
template<>
rgba_pixel_t degate::convert_pixel< rgba_pixel_t, gs_double_pixel_t > ( gs_double_pixel_t  p) [inline]

Convert pixel value from from double -> rgba.

Definition at line 171 of file ImageManipulation.h.

References MERGE_CHANNELS.

                                                                                          {
    gs_byte_pixel_t b = p;
    return MERGE_CHANNELS(b, b, b, 255);
  }
template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::convert_to_greyscale ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src 
)

Convert an image to greyscale.

You can get the same effect if you copy_image() an RGBA into a greyscale image and implicitly use the auto conversion. This function is useful, if you don't have two different image types. Then there would be no auto conversion. You can use that function with dst = src . Then the image is converted in place. Like copy_image() this function works only on the region, in which both images intersect.

See also:
copy_image()

Definition at line 278 of file ImageManipulation.h.

                                                             {

    unsigned int h = std::min(src->get_height(), dst->get_height());
    unsigned int w = std::min(src->get_width(), dst->get_width());

    for(unsigned int y = 0; y < h; y++)
      for(unsigned int x = 0; x < w; x++) {
        gs_byte_pixel_t p = src->template get_pixel_as<gs_byte_pixel_t>(x, y);
        dst->template set_pixel_as<gs_byte_pixel_t>(x, y, p);
      }
  }
template<typename ImageType >
void degate::convert_to_greyscale ( std::shared_ptr< ImageType >  img)

In place conversion to a greyscale image.

See also:
convert_to_greyscale(std::shared_ptr<ImageTypeDst>, std::shared_ptr<ImageTypeSrc>)

Definition at line 297 of file ImageManipulation.h.

                                                          {
    convert_to_greyscale<ImageType, ImageType>(img, img);
  }
template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::convolve ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
FilterKernel_shptr  kernel 
)

Convolve a single channel source image with a filter kernel and write it into a destination image.

Depending on the filter kernel size there is a region next to the image boundary that you cannot use for further processing.

Definition at line 538 of file ImageManipulation.h.

Referenced by degate::TemplateMatching::prepare_background_images().

                                           {

    assert_is_single_channel_image<ImageTypeSrc>();

    clear_image<ImageTypeDst>(dst);

    unsigned int h = std::min(src->get_height(), dst->get_height());
    unsigned int w = std::min(src->get_width(), dst->get_width());

    unsigned int x, y, i, j;

    for(y = kernel->get_center_row(); y < h - kernel->get_center_row(); y++) {
      for(x = kernel->get_center_column(); x < w - kernel->get_center_column(); x++) {

        double accu = 0;

        for(i = 0; i < kernel->get_columns(); i++ ) {
          for(j = 0; j < kernel->get_rows(); j++ ) {

            typename ImageTypeSrc::pixel_type p =
              src->get_pixel(x - kernel->get_center_column() + i,
                             y - kernel->get_center_row() + j);

            double k = kernel->get(kernel->get_columns() - 1 - i,
                                   kernel->get_rows() - 1 - j);
            accu += k * p;
          }
        }
        dst->template set_pixel_as<double>(x, y, accu);
      }
    }
  }

Here is the caller graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::copy_image ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src 
)

Copy an image.

Copy the source image into the destination image. If the images differ in pixel types, the pixel values will be converted. The images can also differ in size. Only the region is copied, which is present in both images. It is possible that the image dst is not completely overwritten, if the image src is not large enough.

Definition at line 209 of file ImageManipulation.h.

Referenced by degate::ProjectImporter::load_background_image(), degate::TemplateMatching::prepare_template(), and degate::ViaMatching::run().

                                                   {


    unsigned int h = std::min(src->get_height(), dst->get_height());
    unsigned int w = std::min(src->get_width(), dst->get_width());

    for(unsigned int y = 0; y < h; y++)
      for(unsigned int x = 0; x < w; x++)
        dst->set_pixel(x, y, src->template get_pixel_as<typename ImageTypeDst::pixel_type>(x, y));
  }

Here is the caller graph for this function:

void degate::create_directory ( std::string const &  directory,
mode_t  mode = 0700 
)

Create a directory.

Definition at line 132 of file FileSystem.cc.

Referenced by degate::ScalingManager< ImageType >::create_scalings(), and degate::StoragePolicy_Tile< PixelPolicy >::StoragePolicy_Tile().

                                                                     {

  if(mkdir(directory.c_str(), mode) != 0) {
    throw degate::FileSystemException(strerror(errno));
  }

}

Here is the caller graph for this function:

Create a temp directory.

Definition at line 140 of file FileSystem.cc.

References generate_temp_file_pattern(), and get_temp_directory().

Referenced by degate::ExternalMatching::run().

Here is the call graph for this function:

Here is the caller graph for this function:

std::string degate::create_temp_directory ( std::string const &  directory_pattern)

Create a temporary directory based on a path pattern specification.

The directory is created with mode 0700.

Parameters:
directory_patternA pattern of the form e.g. "/tmp/temp.XXXXXXXXX".
Returns:
Returns the path of the created directory.

Definition at line 144 of file FileSystem.cc.

                                                                           {
  char template_str[PATH_MAX];
  strncpy(template_str, directory_pattern.c_str(), sizeof(template_str));
  char * dirname = mkdtemp(template_str);
  return std::string(dirname);
}

Determine ports of a root module.

Note: It would b more nice to have this function as a member function of class Module. But this would intorduce a dependency of LogicModel. The lmodel is neccessary for looking up objects, because main module's ports are modelled by having a special emarker in the net. I have no idea how the main module's ports could be identified else. (Using all ports is obviously not an option.)

Definition at line 406 of file Module.cc.

References debug(), and TM.

Referenced by degate::LogicModelExporter::export_data().

                                                                    {
  debug(TM, "Check for module ports.");
  /*
    Iterate over all gate and check their ports.
    Get the net for a port.
    Iterate over net.
    If a net contains a emarker with a description of 'module-port', use
    gate port as module port.
   */

  Module_shptr main_module = lmodel->get_main_module();

  main_module->ports.clear(); // reset ports

  for(Module::gate_collection::iterator g_iter = main_module->gates_begin(); 
      g_iter != main_module->gates_end(); ++g_iter) {

    Gate_shptr gate = *g_iter;
    assert(gate != NULL);

    for(Gate::port_const_iterator p_iter = gate->ports_begin(); p_iter != gate->ports_end(); ++p_iter) {

      GatePort_shptr gate_port = *p_iter;
      assert(gate_port != NULL);

      Net_shptr net = gate_port->get_net();
      bool is_a_port = false;

      if(net != NULL) {

        for(Net::connection_iterator c_iter = net->begin(); c_iter != net->end() && !is_a_port; ++c_iter) {
          
          object_id_t oid = *c_iter;
          assert(oid != 0);
          
          PlacedLogicModelObject_shptr lmo = lmodel->get_object(oid);
          if(EMarker_shptr em = std::dynamic_pointer_cast<EMarker>(lmo)) {
            debug(TM, "Connected with emarker");

            if(em->get_description() == "module-port") {
              
              GateTemplatePort_shptr tmpl_port = gate_port->get_template_port();
              assert(tmpl_port != NULL); // if a gate has no standard cell type, the gate cannot have a port
              
              main_module->ports[em->get_name()] = gate_port;
              is_a_port = true;
            }
          }
        } 
            
      } // end of net-object-iteration
    } // end of gate-portiteration
  } // end of gate-iteration

}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::dilate_image ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
unsigned int  kernel_width = 3,
unsigned int  dilation_threshold = 3 
)

Filter an image with an erosion filter.

Definition at line 113 of file MorphologicalFilter.h.

References filter_image().

                                                         {

    filter_image<ImageTypeDst, ImageTypeSrc,
      DilateImagePolicy<ImageTypeSrc, typename ImageTypeSrc::pixel_type> >
      (dst, src, kernel_width, dilation_threshold);
  }

Here is the call graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::erode_image ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
unsigned int  kernel_width = 3,
unsigned int  erosion_threshold = 3 
)

Filter an image with an erosion filter.

Definition at line 65 of file MorphologicalFilter.h.

References filter_image().

                                                       {

    filter_image<ImageTypeDst, ImageTypeSrc,
      ErodeImagePolicy<ImageTypeSrc, typename ImageTypeSrc::pixel_type> >
      (dst, src, kernel_width, erosion_threshold);
  }

Here is the call graph for this function:

int degate::execute_command ( std::string const &  command,
std::list< std::string > const &  params 
)

Execute a command.

Parameters:
commandThe command to execute.
paramslist of parameters.
Returns:
Returns the exit code.

Definition at line 69 of file DegateHelper.cc.

                                                                                      {

  pid_t pid = fork();
  if(pid == 0) {
    // child
    std::cout << "Execute command " << command << " ";
    char const ** argv = new char const *[params.size()+2];
    int i = 1;
    BOOST_FOREACH(std::string const& s, params) {
      argv[i] = s.c_str();
      i++;
      std::cout << s << " ";
    }
    argv[0] = command.c_str();
    argv[i] = NULL;

    std::cout << std::endl;

    if(execvp(command.c_str(), const_cast<char* const*>(argv)) == -1) {
      std::cout << "exec failed" << std::endl;
    }
    std::cout << "sth. failed" << std::endl;
    exit(0);
  }
  else if(pid < 0) {
    // fork failed
    throw SystemException("fork() failed");
  }
  else {

    // parent
    int exit_code;
    if(waitpid(pid, &exit_code, 0) != pid)
      throw SystemException("waitpid() failed");
    else {
      if(WEXITSTATUS(exit_code) != 0) {
        std::string errmsg("Failed to execute command: " + command);
        BOOST_FOREACH(std::string const& s, params) {
          errmsg += " ";
          errmsg += s;
        }
        errmsg += ". Error: ";
        errmsg += strerror(errno);
        throw SystemException(errmsg);
      }
      return  exit_code;    
    }
  }
}
template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::extract_partial_image ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
unsigned int  min_x,
unsigned int  max_x,
unsigned int  min_y,
unsigned int  max_y 
)

Extract a partial image from src with the region defined by the parameters into a destination image dst.

Clipping occurs, if the destination image is smaller than the region or the image src.

Definition at line 228 of file ImageManipulation.h.

Referenced by degate::TemplateMatching::prepare_background_images(), degate::IPCopy< ImageTypeIn, ImageTypeOut >::run(), and save_part_of_image().

                                                                     {

    assert(min_x < max_x);
    assert(min_y < max_y);

    unsigned int h = std::min(std::min(std::min(src->get_height(), max_y), dst->get_height()), max_y - min_y);
    unsigned int w = std::min(std::min(std::min(src->get_width(), max_x), dst->get_width()), max_x - min_x);

    unsigned int dst_x = 0, dst_y = 0, x, y;

    for(y = min_y; y < min_y + h; y++, dst_y++) {
      for(x = min_x, dst_x = 0; x < min_x + w; x++, dst_x++)
        dst->set_pixel(dst_x, dst_y,
                       src->template get_pixel_as<typename ImageTypeDst::pixel_type>(x, y));
    }
  }

Here is the caller graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::extract_partial_image ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
BoundingBox const &  bounding_box 
)

Extract a partial image.

See also:
extract_partial_image()

Definition at line 253 of file ImageManipulation.h.

References degate::BoundingBox::get_max_x(), degate::BoundingBox::get_max_y(), degate::BoundingBox::get_min_x(), and degate::BoundingBox::get_min_y().

                                                              {

    extract_partial_image<ImageTypeDst, ImageTypeSrc>(dst, src,
                                                      bounding_box.get_min_x(),
                                                      bounding_box.get_max_x(),
                                                      bounding_box.get_min_y(),
                                                      bounding_box.get_max_y());
  }

Here is the call graph for this function:

bool degate::file_exists ( std::string const &  path)

Check if a file or directory exists.

Returns:
Returns true, if the file or directory exist.

Definition at line 73 of file FileSystem.cc.

Referenced by degate::ScalingManager< ImageType >::create_scalings(), get_basedir(), degate::ProjectImporter::import_all(), degate::ProjectImporter::load_background_image(), load_degate_image(), load_image(), degate::ScalingManager< ImageType >::ScalingManager(), and degate::StoragePolicy_Tile< PixelPolicy >::StoragePolicy_Tile().

                                               {
  struct stat stat_buf;
  return stat(path.c_str(), &stat_buf) == 0 ? true : false;
}

Here is the caller graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc , typename FunctionPolicy >
void degate::filter_image ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
unsigned int  kernel_width = 3,
unsigned int  threshold = 3 
)

Filter an (RBGA) image.

Parameters:
thresholdThe threshold parameter is directly passed to the calculate() method of the calculation policy class.
Exceptions:
DegateRuntimeExceptionThis exception is thrown if your images are to small for the kernel or if the width of the kernel is to small.

Definition at line 585 of file ImageManipulation.h.

Referenced by dilate_image(), erode_image(), median_filter(), morphological_close(), and morphological_open().

                                                {

    if(kernel_width <= 1)
      throw DegateRuntimeException("Error in filter_image(). Kernel width is to small.");

    unsigned int width = std::min(src->get_width(), dst->get_width());
    unsigned int height = std::min(src->get_height(), dst->get_height());

    if(width < kernel_width || height < kernel_width)
      throw DegateRuntimeException("Error in filter_image(). One of the images is to small.");

    unsigned int kernel_center = kernel_width / 2;

    width -= (kernel_width - kernel_center);
    height -= (kernel_width - kernel_center);

    for(unsigned int y = kernel_center; y < height; y++) {
      for(unsigned x = kernel_center; x < width; x++) {

        typename ImageTypeSrc::pixel_type out =
          FunctionPolicy::calculate(src,
                                    x, y,
                                    x - kernel_center,
                                    x - kernel_center + kernel_width,
                                    y - kernel_center,
                                    y - kernel_center + kernel_width,
                                    threshold);

        dst->template set_pixel_as<typename ImageTypeSrc::pixel_type>(x, y, out);
      }
    }

  }

Here is the caller graph for this function:

template<typename ImageType >
void degate::flip_both ( std::shared_ptr< ImageType >  img)

Flip image in place from top to down and from left to right.

Definition at line 73 of file ImageManipulation.h.

Referenced by degate::TemplateMatching::prepare_template().

                                               {
    flip_up_down<ImageType>(img);
    flip_left_right<ImageType>(img);
  }

Here is the caller graph for this function:

template<typename ImageType >
void degate::flip_left_right ( std::shared_ptr< ImageType >  img)

Flip image in place from left to right.

Definition at line 39 of file ImageManipulation.h.

Referenced by degate::TemplateMatching::prepare_template().

                                                     {
    if(img->get_width() == 1) return;

    for(unsigned int y = 0; y < img->get_height(); y++)
      for(unsigned int x = 0; x < (img->get_width() >> 1); x++) {
        unsigned int other_x = img->get_width() - 1 - x;
        typename ImageType::pixel_type p1 = img->get_pixel(x, y);
        typename ImageType::pixel_type p2 = img->get_pixel(other_x, y);
        img->set_pixel(x, y, p2);
        img->set_pixel(other_x, y, p1);
      }
  }

Here is the caller graph for this function:

template<typename ImageType >
void degate::flip_up_down ( std::shared_ptr< ImageType >  img)

Flip image in place from top to down.

Definition at line 56 of file ImageManipulation.h.

Referenced by degate::TemplateMatching::prepare_template().

                                                  {
    if(img->get_height() == 1) return;

    for(unsigned int y = 0; y < (img->get_height() >> 1); y++)
      for(unsigned int x = 0; x < img->get_width(); x++) {
        unsigned int other_y = img->get_height() - 1 - y;
        typename ImageType::pixel_type p1 = img->get_pixel(x, y);
        typename ImageType::pixel_type p2 = img->get_pixel(x, other_y);
        img->set_pixel(x, y, p2);
        img->set_pixel(x, other_y, p1);
      }
  }

Here is the caller graph for this function:

std::string degate::gen_tabs ( int  n)

Definition at line 45 of file debug.cc.

Referenced by degate::BoundingBox::print(), degate::EMarker::print(), degate::Via::print(), degate::Annotation::print(), degate::GatePort::print(), degate::QuadTree< T >::print(), and degate::Gate::print().

                                {
  std::string ret;
  for(int i = 0; i < n; i++)
    ret += "\t";
  return ret;
}

Here is the caller graph for this function:

std::string degate::generate_temp_file_pattern ( std::string const &  basedir)

Generate a pattern within a basedir for temp files.

The pattern is in the form of e.g. "/tmp/temp.XXXXXXXX" that can be passed to mkstemp(). Only the pattern is generated.

Definition at line 152 of file FileSystem.cc.

Referenced by create_temp_directory(), and write_string_to_temp_file().

                                                                      {
  return basedir + std::string("/temp.XXXXXXXXXXX");
}

Here is the caller graph for this function:

Get layer pointers for the first transistor layer and M1 and M2, if they are available.

Definition at line 109 of file LogicModelHelper.cc.

References debug(), get_first_layer(), get_first_logic_layer(), degate::Layer::METAL, TM, and degate::Layer::TRANSISTOR.

Referenced by grab_template_images(), and merge_gate_images().

                                                                                  {

  std::list<Layer_shptr> layers;
  Layer_shptr l;

  try {
    l = get_first_layer(lmodel, Layer::TRANSISTOR);
    if(l != NULL) layers.push_back(l);
  }
  catch(CollectionLookupException const& ex) {
    debug(TM, "Got an exception. A layer is not available. I will ignore it: %s", ex.what());
  }

  try {
    l = get_first_logic_layer(lmodel);
    if(l != NULL) layers.push_back(l);
  }
  catch(CollectionLookupException const& ex) {
    debug(TM, "Got an exception. A layer is not available. I will ignore it: %s", ex.what());
  }

  try {
    l = get_first_layer(lmodel, Layer::METAL);
    if(l != NULL) layers.push_back(l);
  }
  catch(CollectionLookupException const& ex) {
    debug(TM, "Got an exception. A layer is not available. I will ignore it: %s", ex.what());
  }

  return layers;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string degate::get_basedir ( std::string const &  path)

Get the base directory for file or directory.

It is no problem if you request the basedir for a symlink on a directory, because the path is internally expanded via get_realpath(), but only if the file exist. If you use get_basedir() on a non existing path, the path is treated as a path to a file. Then the file name part is stripped.

Returns:
Returns a string with the base directory.
Exceptions:
Throwsan InvalidPathException if the path does not exists.
See also:
get_realpath()

Definition at line 78 of file FileSystem.cc.

References file_exists(), get_realpath(), and is_directory().

Referenced by degate::RCVBlacklistExporter::export_data(), degate::GateLibraryExporter::export_data(), degate::GateLibraryImporter::import(), degate::ProjectImporter::import(), degate::ProjectImporter::import_all(), and degate::RCVBlacklistImporter::import_into().

                                                    {

  std::string resolved_path;

  if(file_exists(path)) {
    resolved_path = get_realpath(path);

    if(is_directory(resolved_path)) return resolved_path;
    else {
      return resolved_path.substr(0, resolved_path.find_last_of('/'));
    }
  }
  else {
    // treat it as a file name
    size_t last_pos = path.find_last_of('/');
    if(last_pos != 0)
      return path.substr(0, last_pos);
    else return "/";
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string degate::get_basename ( std::string const &  path)

Get the basename of a file.

That is the substring without the directory part, the suffix and the dot.

Test:
FileSystemTest::test_get_basename()

Definition at line 195 of file FileSystem.cc.

References get_filename_from_path().

Referenced by degate::LogicModelDOTExporter::export_data().

                                                    {
  std::string filename(get_filename_from_path(path));

  size_t last_occurance = filename.rfind(".", filename.size());
  if(last_occurance < filename.size())
    return filename.substr(0, last_occurance);
  else return filename;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Get the current layer.

Definition at line 332 of file LogicModelHelper.cc.

                                                           {
  if(project == NULL)
    throw InvalidPointerException("Invalid parameter for get_curent_layer()");

  LogicModel_shptr lmodel = project->get_logic_model();
  assert(lmodel != NULL);
  return lmodel->get_current_layer();
}
std::string degate::get_file_suffix ( std::string const &  path)

Get a file suffix without the dot, e.g.

"xml" from a file named "foobar.xml".

Returns:
Returns the file suffix as a string. If the file has no suffix, an empty string is returned. The suffix is returned as it is. There is no lowercase conversion or somthing like that.

Definition at line 112 of file FileSystem.cc.

Referenced by degate::ImageReaderFactory< ImageType >::get_reader().

                                                       {
  size_t last_occurance = path.rfind(".", path.size());
  if(last_occurance < path.size()) {
    return path.substr(last_occurance + 1, path.size() - last_occurance);
  }
  else return std::string();
}

Here is the caller graph for this function:

std::string degate::get_filename_from_path ( std::string const &  path)

Get filename part of a path.

Definition at line 187 of file FileSystem.cc.

Referenced by degate::ProjectArchiver::add_directory(), and get_basename().

                                                              {
  size_t last_occurance = path.rfind("/", path.size());
  if(last_occurance < path.size()) {
    return path.substr(last_occurance + 1, path.size() - last_occurance);
  }
  else return path;
}

Here is the caller graph for this function:

Get first enabled layer

Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer for layer, then this exception is raised.

Exceptions:
CollectionLookupExceptionIs thrown, if all layers are disabled.

Definition at line 232 of file LogicModelHelper.cc.

                                                                   {
  if(lmodel == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to get_first_enabled_layer()");

  for(LogicModel::layer_collection::iterator iter = lmodel->layers_begin();
      iter != lmodel->layers_end(); ++iter) {
    Layer_shptr layer = *iter;

    if(layer->is_enabled()) return layer;
  }
  throw InvalidPointerException("Error: all layers are disabled.");
}

Get the first layer of a layer type.

The search order is from bottom to top (lower layer position numbers to higher). Method ignores disabled layers.

Exceptions:
InvalidPointerExceptionIs thrown if you passed an invalid pointer for lmodel .
DegateLogicExceptionThis exception is thrown if you passed an invalid layer_type.
CollectionLookupExceptionIs thrown if there is no layer of the requested type.

Definition at line 33 of file LogicModelHelper.cc.

References degate::Layer::get_layer_type_as_string(), and degate::Layer::UNDEFINED.

Referenced by get_available_standard_layers(), and get_first_logic_layer().

                                                                                       {

  if(layer_type == Layer::UNDEFINED)
    throw DegateLogicException("Invalid layer type.");

  if(lmodel == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to get_first_layer()");

  for(LogicModel::layer_collection::iterator iter = lmodel->layers_begin();
      iter != lmodel->layers_end(); ++iter) {
    Layer_shptr layer = *iter;

    if(layer->is_enabled() && layer->get_layer_type() == layer_type)
      return layer;
  }

  boost::format fmter("Can't lookup layer of type %1% in logic model.");
  fmter % Layer::get_layer_type_as_string(layer_type);
  throw CollectionLookupException(fmter.str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Get the first layer that is a logic layer.

The search order is from bottom to top (lower layer position numbers to higher). Method ignores disabled layers.

Exceptions:
InvalidPointerExceptionIs thrown if you passed an invalid pointer for lmodel .
CollectionLookupExceptionIs thrown if there is no logc layer.

Definition at line 54 of file LogicModelHelper.cc.

References get_first_layer(), and degate::Layer::LOGIC.

Referenced by degate::AutoNameGates::AutoNameGates(), and get_available_standard_layers().

                                                                 {

  if(lmodel == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to get_first_logic_layer()");
  try {
    return get_first_layer(lmodel, Layer::LOGIC);
  }
  catch(CollectionLookupException const& ex) {
    throw;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gate_shptr degate::get_gate_by_name ( LogicModel_shptr  lmodel,
std::string const &  gate_name 
)

Lookup a gate by it's name.

The name should be unique. If there is more then one gate with that name, the first one is returned.

Returns:
Returns a shared pointer to the gate. This pointer can represent a NULL pointer, if no gate was found.

Definition at line 67 of file LogicModelHelper.cc.

                                                                {
  for(LogicModel::gate_collection::iterator iter = lmodel->gates_begin();
      iter != lmodel->gates_end(); ++iter) {
    Gate_shptr gate = (*iter).second;
    if(gate->get_name() == gate_name) return gate;
  }

  return Gate_shptr();
}
template<typename ImageType >
ImageType::pixel_type degate::get_maximum ( std::shared_ptr< ImageType >  img)

Get the maximum pixel value of a single channel image.

Definition at line 56 of file ImageStatistics.h.

                                                                         {

    assert_is_single_channel_image<ImageType>();
    typename ImageType::pixel_type maximum = img->get_pixel(0, 0);

    for(unsigned int y = 0; y < img->get_height(); y++)
      for(unsigned int x = 0; x < img->get_width(); x++) {
        typename ImageType::pixel_type p = img->get_pixel(x, y);
        if(p > maximum) maximum = p;
      }
    return maximum;
  }
template<typename ImageType >
ImageType::pixel_type degate::get_minimum ( std::shared_ptr< ImageType >  img)

Get the minimum pixel value of a single channel image.

Definition at line 39 of file ImageStatistics.h.

                                                                         {

    assert_is_single_channel_image<ImageType>();
    typename ImageType::pixel_type minimum = img->get_pixel(0, 0);

    for(unsigned int y = 0; y < img->get_height(); y++)
      for(unsigned int x = 0; x < img->get_width(); x++) {
        typename ImageType::pixel_type p = img->get_pixel(x, y);
        if(p < minimum) minimum = p;
      }
    return minimum;
  }

Get next enabled layer.

Returns:
Returns the "next" visible layer relative to the current layer. If the current layer is the top layer, the bottom layer is returned.
Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer for layer, then this exception is raised.
CollectionLookupExceptionIs thrown, if all layers are disabled.
DegateRuntimeExceptionIs thrown, if there is no current layer.

Definition at line 245 of file LogicModelHelper.cc.

Referenced by autoconnect_interlayer_objects().

                                                                  {
  if(lmodel == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to get_next_enabled_layer()");

  Layer_shptr curr_layer = lmodel->get_current_layer();
  if(curr_layer == NULL)
    throw DegateRuntimeException("Error: there is no current layer.");

  for(unsigned int l_pos = curr_layer->get_layer_pos() + 1;
      l_pos < lmodel->get_num_layers(); l_pos++) {
    Layer_shptr layer = lmodel->get_layer(l_pos);
    if(layer->is_enabled()) return layer;
  }

  return curr_layer;

  /*
  for(unsigned int l_pos = curr_layer->get_layer_pos() + 1;
      l_pos <= curr_layer->get_layer_pos() + lmodel->get_num_layers(); l_pos++) {
    Layer_shptr layer = lmodel->get_layer(l_pos % lmodel->get_num_layers());
    if(layer->is_enabled()) return layer;
  }
  
  throw InvalidPointerException("Error: all layers are disabled.");
  return Layer_shptr(); // to avoid compiler warning
  */
}

Here is the caller graph for this function:

Get the next enabled layer, that is above layer.

The method will not turn around in the layer stack.

Returns:
Returns the next layer. If there is no next layer, a NULL pointer is returned.
Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer, then this exception is raised.

Definition at line 274 of file LogicModelHelper.cc.

                                                                                     {

  if(lmodel == NULL || layer == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to get_next_enabled_layer()");

  for(unsigned int l_pos = layer->get_layer_pos() + 1;
      l_pos < lmodel->get_num_layers(); l_pos++) {
    Layer_shptr l = lmodel->get_layer(l_pos);
    if(l->is_enabled()) return l;
  }

  return Layer_shptr();
}
template<typename PixelTypeDst , typename ImageTypeSrc >
PixelTypeDst degate::get_pixel_as ( typename std::shared_ptr< ImageTypeSrc >  img,
unsigned int  x,
unsigned int  y 
) [inline]

Definition at line 184 of file ImageManipulation.h.

                                                                   {
    return convert_pixel<PixelTypeDst, typename ImageTypeSrc::pixel_type>(img->get_pixel(x, y));
  }

Get the port type of a gate port.

Returns:
Returns the port type or GateTemplatePort::PORT_TYPE_UNDEFINED if the port type cannot be determined.

Definition at line 359 of file LogicModelHelper.cc.

References degate::GateTemplatePort::PORT_TYPE_UNDEFINED.

Referenced by degate::LookupSubcircuit::filter_connected_gates().

                                                                        {

  if(gate_port == NULL)
    throw InvalidPointerException("Invalid parameter for get_port_type()");

  if(gate_port->has_template_port()) {
    GateTemplatePort_shptr tmpl_port = gate_port->get_template_port();
    return tmpl_port->get_port_type();
  }

  return GateTemplatePort::PORT_TYPE_UNDEFINED;
}

Here is the caller graph for this function:

Get previous enabled layer.

Returns:
Returns the "previous" visible layer relative to the current layer. If the current layer is the bottom layer, the top layer is returned.
Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer for layer, then this exception is raised.
CollectionLookupExceptionIs thrown, if all layers are disabled.
DegateRuntimeExceptionIs thrown, if there is no current layer.

Definition at line 288 of file LogicModelHelper.cc.

Referenced by autoconnect_interlayer_objects().

                                                                  {

  if(lmodel == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to get_prev_enabled_layer()");

  Layer_shptr curr_layer = lmodel->get_current_layer();
  if(curr_layer == NULL)
    throw DegateRuntimeException("Error: there is no current layer.");


  if(curr_layer->get_layer_pos() == 0) return curr_layer;

  for(int l_pos = curr_layer->get_layer_pos() - 1; l_pos >= 0; l_pos--) {
    Layer_shptr layer = lmodel->get_layer(l_pos);
    if(layer->is_enabled()) return layer;
  }
  return curr_layer;

  /*
  if(lmodel->get_num_layers() == 1) return curr_layer;

  for(unsigned int l_pos = curr_layer->get_layer_pos() + lmodel->get_num_layers() - 1;
      l_pos > 0; l_pos--) {
    Layer_shptr layer = lmodel->get_layer(l_pos % lmodel->get_num_layers());
    if(layer->is_enabled()) return layer;
  }
  throw InvalidPointerException("Error: all layers are disabled.");
  return Layer_shptr(); // to avoid compiler warning
  */
}

Here is the caller graph for this function:

Get the previous enabled layer, that is below layer.

The method will not turn around in the layer stack.

Returns:
Returns the previous layer. If there is no previous layer, a NULL pointer is returned.
Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer, then this exception is raised.

Definition at line 319 of file LogicModelHelper.cc.

                                                                                     {

  if(lmodel == NULL || layer == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to get_prev_enabled_layer()");

  for(unsigned int l_pos = layer->get_layer_pos(); l_pos > 0; l_pos--) {

    Layer_shptr l = lmodel->get_layer(l_pos - 1);
    if(l->is_enabled()) return l;
  }
  return Layer_shptr();
}
std::string degate::get_realpath ( std::string const &  path)

Get the canonicalized absolute pathname.

Returns:
Returns the resolved path as an absolut path name.
Exceptions:
Throwsan InvalidPathException if the path does not exists.

Definition at line 101 of file FileSystem.cc.

Referenced by get_basedir(), degate::Configuration::get_temp_directory(), and read_directory().

                                                    {
  char resolved_path[PATH_MAX];
  if(realpath(path.c_str(), resolved_path) == NULL) {
    boost::format fmter("Error in get_realpath(). Can't get real path for %1%.");
    fmter % path;
    throw degate::InvalidPathException(fmter.str());
  }
  else return std::string(resolved_path);
}

Here is the caller graph for this function:

std::string degate::get_relative_path ( std::string const &  path,
std::string const &  relative_to 
)

Make a path specification relative to another.

Definition at line 333 of file FileSystem.cc.

References _get_relative_path().

Referenced by degate::ProjectExporter::add_layers().

                                                                    {

  //boost::format fmter("\npath=%1%\nrelative_to=%2%");
  //fmter % path % relative_to;
  //std::cout << fmter.str() << std::endl;

  char * rel_path = _get_relative_path(path.c_str(), relative_to.c_str());

  std::string ret(rel_path);

  //std::cout << "rel_path=" << ret << std::endl;

  free(rel_path);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string degate::get_temp_directory ( )

Get the temp directory.

This is a shortcut for (Configuration::get_instance()).get_temp_directory() .

Definition at line 29 of file Configuration.cc.

References degate::SingletonBase< Configuration >::get_instance(), and degate::Configuration::get_temp_directory().

Referenced by create_temp_directory().

                                     {
  Configuration const & conf = Configuration::get_instance();
  return conf.get_temp_directory();
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string degate::get_template_port_name ( GatePort_shptr  gate_port)

Get the name of a corresponding template port.

Returns:
Returns the name of the corresponding template name. If there is no name an empty string is returned.

Definition at line 373 of file LogicModelHelper.cc.

Referenced by degate::LookupSubcircuit::filter_connected_gates().

                                                                 {

  if(gate_port == NULL)
    throw InvalidPointerException("Invalid parameter for get_template_port_name()");

  if(gate_port->has_template_port()) {
    GateTemplatePort_shptr tmpl_port = gate_port->get_template_port();
    return tmpl_port->get_name();
  }

  return "";
}

Here is the caller graph for this function:

template<typename ImageType >
std::shared_ptr<ImageType> degate::grab_image ( LogicModel_shptr  lmodel,
Layer_shptr  layer,
BoundingBox const &  bounding_box 
)

Extract a partial image from the background image for a layer.

Exceptions:
DegateLogicExceptionIs thrown if the layer has no background image set.

Definition at line 90 of file LogicModelHelper.h.

References degate::BoundingBox::get_height(), and degate::BoundingBox::get_width().

                                                                              {

    // create empty image with the size of the bounding box
    std::shared_ptr<ImageType> new_img(new ImageType(bounding_box.get_width(),
                                                          bounding_box.get_height()));

    BackgroundImage_shptr bg_image = layer->get_image();
    if(bg_image == NULL) throw DegateLogicException("The layer has no background image");

    extract_partial_image<ImageType, BackgroundImage>(new_img, bg_image, bounding_box);

    //save_image<ImageType>("/tmp/zzz.tif", new_img);

    return new_img;
  }

Here is the call graph for this function:

void degate::grab_template_images ( LogicModel_shptr  lmodel,
GateTemplate_shptr  gate_template,
BoundingBox const &  bounding_box,
Gate::ORIENTATION  orientation = Gate::ORIENTATION_NORMAL 
)

Extract a partial image from the background images for several layers and set the extracted images as master images for a gate template.

This operation happens for the first transistor layer, for the first logic layer and for the first metal layer, but only if a layer of a type exists. With the paramter orientation you can specify that a flipping of the image is necessary.

Definition at line 142 of file LogicModelHelper.cc.

References debug(), get_available_standard_layers(), degate::Gate::ORIENTATION_FLIPPED_BOTH, degate::Gate::ORIENTATION_FLIPPED_LEFT_RIGHT, degate::Gate::ORIENTATION_FLIPPED_UP_DOWN, TM, and degate::Layer::UNDEFINED.

Referenced by degate::ProjectImporter::import_all().

                                                               {

  std::list<Layer_shptr> layers = get_available_standard_layers(lmodel);

  for(std::list<Layer_shptr>::iterator iter = layers.begin();
      iter != layers.end(); ++iter) {

    Layer_shptr layer = *iter;
    assert(layer->get_layer_type() != Layer::UNDEFINED);
    debug(TM, "grab image from %s layer",
          layer->get_layer_type_as_string().c_str());

    // extract image

    GateTemplateImage_shptr tmpl_img =
      grab_image<GateTemplateImage>(lmodel, layer, bounding_box);
    assert(tmpl_img != NULL);

    // flip
    switch(orientation) {
    case Gate::ORIENTATION_FLIPPED_UP_DOWN:
      flip_up_down<GateTemplateImage>(tmpl_img);
      break;
    case Gate::ORIENTATION_FLIPPED_LEFT_RIGHT:
      flip_left_right<GateTemplateImage>(tmpl_img);
      break;
    case Gate::ORIENTATION_FLIPPED_BOTH:
      flip_up_down<GateTemplateImage>(tmpl_img);
      flip_left_right<GateTemplateImage>(tmpl_img);
      break;
    default:
      // do nothing
      break;
    }

    // set as master image
    gate_template->set_image(layer->get_layer_type(), tmpl_img);

  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >
void degate::ignore_unused_variable_warning ( T const &  ) [inline]

A dummy method to get rid of compiler warnings.

Definition at line 35 of file TypeConstraints.h.

Referenced by degate::assert_is_multi_channel_image< ImageType >::assert_is_multi_channel_image(), and degate::assert_is_single_channel_image< ImageType >::assert_is_single_channel_image().

{}

Here is the caller graph for this function:

bool degate::is_directory ( std::string const &  path)

Check if a path is a directory.

Returns:
Returns true, if the path is a dirctory. It returns false, if not or if the path doesn't exists.
Todo:
Instead of writing own wrapper functions, it would be better to use the boost filesystem abstraction.

Definition at line 49 of file FileSystem.cc.

Referenced by degate::ProjectArchiver::add_directory(), degate::ScalingManager< ImageType >::create_scalings(), degate::ProjectExporter::export_all(), get_basedir(), degate::ProjectImporter::get_project_filename(), degate::ProjectImporter::load_background_image(), and degate::ExternalMatching::run().

                                                {
  struct stat stat_buf;
  if(stat(path.c_str(), &stat_buf) == 0) {
    return S_ISDIR(stat_buf.st_mode) ? true : false;
  }
  return false;
}

Here is the caller graph for this function:

bool degate::is_file ( std::string const &  path)

Check if a path is a regular file.

Returns:
Returns true, if the path is a regular file. It returns false, if not or if the path doesn't exist.

Definition at line 57 of file FileSystem.cc.

Referenced by degate::Importer::check_file(), and degate::ProjectImporter::load_background_image().

                                           {
  struct stat stat_buf;
  if(stat(path.c_str(), &stat_buf) == 0) {
    return S_ISREG(stat_buf.st_mode) ? true : false;
  }
  return false;
}

Here is the caller graph for this function:

Check if an object can be electrically interconnected with another object.

Definition at line 34 of file ObjectSet.cc.

                                                               {
  return std::dynamic_pointer_cast<ConnectedLogicModelObject>(o) != NULL;
}
bool degate::is_logic_class ( Gate_shptr  gate,
std::string const &  logic_class 
)

Check if a gate is of a specific logic class.

Definition at line 341 of file LogicModelHelper.cc.

Referenced by degate::LookupSubcircuit::filter_connected_gates(), and degate::LookupSubcircuit::initialize_openlist().

                                                                         {

  if(gate == NULL)
    throw InvalidPointerException("Invalid parameter for is_logic_class()");

  if(gate->has_template()) {
    GateTemplate_shptr gate_tmpl = gate->get_gate_template();
    std::string const& lclass = gate_tmpl->get_logic_class();
    if(logic_class == lclass) return true;
    if(logic_class.size() < lclass.size()) {
      if(lclass.substr(0, logic_class.size()) == logic_class) return true;
    }
  }

  return false;
}

Here is the caller graph for this function:

template<typename Type >
bool degate::is_of_object_type ( PlacedLogicModelObject_shptr  o)

Definition at line 44 of file ObjectSet.h.

                                                         {
    return std::dynamic_pointer_cast<Type>(o) != NULL;
  }

Returns true if the object can be removed from the Logic Model.

Definition at line 30 of file ObjectSet.cc.

                                                        {
  return std::dynamic_pointer_cast<GatePort>(o) == NULL;
}
bool degate::is_symlink ( std::string const &  path)

Check if a path is a symlink.

Returns:
Returns true, if the path is a symlink. It returns false, if not or if the path doesn't exist.

Definition at line 65 of file FileSystem.cc.

                                              {
  struct stat stat_buf;
  if(stat(path.c_str(), &stat_buf) == 0) {
    return S_ISLNK(stat_buf.st_mode) ? true : false;
  }
  return false;
}
template<class InputIterator >
void degate::isolate_objects ( LogicModel_shptr  lmodel,
InputIterator  first,
InputIterator  last 
)

Isolate objects.

Unused nets are removed from the logic model.

Exceptions:
DegateRuntimeExceptionThis exception is thrown if one of the objects is not of type ConnectedLogicModelObject. This means that the object cannot be connected with anything.
InvalidPointerExceptionIf you pass an invalid shared pointer for the logic model, then this exception is raised.

Definition at line 181 of file LogicModelHelper.h.

                                                                                         {

    if(lmodel == NULL)
      throw InvalidPointerException("You passed an invalid shared pointer for lmodel");

    // collect nets
    std::set<Net_shptr> nets;
    try {
      nets = collect_nets<InputIterator>(first, last);
    }
    catch(DegateRuntimeException const& ex) {
      throw;
    }

    // unconnect objects
    for(InputIterator it = first; it != last; ++it) {
      ConnectedLogicModelObject_shptr clo =
        std::dynamic_pointer_cast<ConnectedLogicModelObject>(*it);

      if(clo == NULL) {
        throw DegateRuntimeException("Error in isolate_objecs(). One of the object "
                                     "cannot be connected with anything");
      }
      else clo->remove_net();
    }

    // check nets: remove them from the logic model if they are not in use
    for(std::set<Net_shptr>::iterator iter = nets.begin(); iter != nets.end(); ++iter)
      if((*iter)->size() == 0) lmodel->remove_net(*iter);

  }
std::string degate::join_pathes ( std::string const &  base_path,
std::string const &  extension_path 
)
void degate::load_background_image ( Layer_shptr  layer,
std::string const &  project_dir,
std::string const &  image_file 
)

Load an image in a common image format as background image for a layer.

If there is already a background image, it will be unset and removed from the project directory.

Exceptions:
InvalidPointerExceptionIf you pass an invalid shared pointer for layer, then this exception is raised.

Definition at line 187 of file LogicModelHelper.cc.

References debug(), join_pathes(), and TM.

Referenced by degate::ProjectImporter::parse_layers_element().

                                                                {

  if(layer == NULL)
    throw InvalidPointerException("Error: you passed an invalid pointer to load_background_image()");

  boost::format fmter("layer_%1%.dimg");
  fmter % layer->get_layer_id(); // was get_layer_pos()

  std::string dir(join_pathes(project_dir, fmter.str()));

  if(layer->has_background_image())
    layer->unset_image();

  debug(TM, "Create background image in %s", dir.c_str());
  BackgroundImage_shptr bg_image(new BackgroundImage(layer->get_width(),
                                                     layer->get_height(),
                                                     dir));

  debug(TM, "Load image %s", image_file.c_str());
  load_image<BackgroundImage>(image_file, bg_image);

  debug(TM, "Set image to layer.");
  layer->set_image(bg_image);
  debug(TM, "Done.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename ImageType >
std::shared_ptr<ImageType> degate::load_degate_image ( unsigned int  width,
unsigned int  height,
std::string const &  path 
)

Helper function to load existing images in a degate image format.

We assume that the file or directory, where the image is stored, exists.

Exceptions:
InvalidPathExceptionThis exception is thrown, if the path doen't exists.

Definition at line 423 of file ImageManipulation.h.

References file_exists().

                                                                           {
    if(!file_exists(path)) {
      boost::format fmter("Error in load_degate_image(): The image file or directory %1% does not exist.");
      fmter % path;
      throw InvalidPathException(fmter.str());
    }
    return std::shared_ptr<ImageType>(new ImageType(width, height, path));
  }

Here is the call graph for this function:

template<typename ImageType >
std::shared_ptr<ImageType> degate::load_image ( std::string const &  path)

Load an image in a common image format, such as tiff.

Exceptions:
InvalidPathExceptionThrown if, path does not exists.
DegateRuntimeExceptionThis exception is thrown, if there is no matching image importer or if the import failed.

Definition at line 47 of file ImageHelper.h.

References debug(), file_exists(), degate::ImageReaderFactory< ImageType >::get_reader(), and TM.

                                                             {
    if(!file_exists(path)) {
      boost::format fmter("Error in load_image(): file %1% does not exist.");
      fmter % path;
      throw InvalidPathException(fmter.str());
    }
    else {
      boost::format fmter("Error in load_image(): The image file %1% cannot be loaded.");
      fmter % path;

      // get a reader
      ImageReaderFactory<ImageType> ir_factory;
      std::shared_ptr<ImageReaderBase<ImageType> > reader = ir_factory.get_reader(path);

      if(reader->read() == false) {
        throw DegateRuntimeException(fmter.str());
      }
      else {

        debug(TM, "reading image file: %s", path.c_str());

        // create an empty image
        std::shared_ptr<ImageType> img(new ImageType(reader->get_width(),
                                                          reader->get_height()));
        if(reader->get_image(img) == true)
          return img;
        else
          throw DegateRuntimeException(fmter.str());
      }
    }
  }

Here is the call graph for this function:

template<typename ImageType >
void degate::load_image ( std::string const &  path,
std::shared_ptr< ImageType >  img 
)

Load an image in a common image format, such as tiff, into an existing degate image.

Exceptions:
InvalidPointerExceptionThis exception is thrown, if parameter img represents an invalid pointer.

Definition at line 85 of file ImageHelper.h.

                                                                       {

    if(img == NULL) throw InvalidPointerException("invalid image pointer");
    std::shared_ptr<ImageType> i = load_image<ImageType>(path);
    copy_image<ImageType, ImageType>(img, i);
  }
template<typename T >
T degate::median ( std::vector< T > &  v) [inline]

Calculate the median of a vector.

Exceptions:
DegateRuntimeExceptionThis exception is thrown if vector's size is 0.

Definition at line 36 of file Statistics.h.

                                    {

    if(v.empty())
      throw DegateRuntimeException("Error in median(): The vector is empty.");

    std::sort(v.begin(), v.end());

    unsigned int center = v.size()/2;

    if(v.size() % 2 == 0) {
      return (v[center - 1] + v[center + 1]) / 2;
    }
    else
      return v[center];
  }
template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::median_filter ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
unsigned int  kernel_width = 3 
)

Filter an image with a median filter.

Definition at line 115 of file MedianFilter.h.

References filter_image().

Referenced by degate::TemplateMatching::prepare_background_images(), and degate::EdgeDetection::setup_pipe().

                                                    {

    filter_image<ImageTypeDst, ImageTypeSrc,
      CalculateImageMedianPolicy<ImageTypeSrc, typename ImageTypeSrc::pixel_type> >(dst, src, kernel_width);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void degate::merge_gate_images ( LogicModel_shptr  lmodel,
Layer_shptr  layer,
GateTemplate_shptr  tmpl,
std::list< Gate_shptr > const &  gates 
)

Merge images.

Definition at line 418 of file LogicModelHelper.cc.

References degate::Gate::ORIENTATION_FLIPPED_BOTH, degate::Gate::ORIENTATION_FLIPPED_LEFT_RIGHT, and degate::Gate::ORIENTATION_FLIPPED_UP_DOWN.

Referenced by merge_gate_images().

                                                                 {

  if(gates.empty()) return;

  std::list<GateTemplateImage_shptr> images;

  BOOST_FOREACH(const Gate_shptr g, gates) {

    GateTemplateImage_shptr tmpl_img =
      grab_image<GateTemplateImage>(lmodel, layer, g->get_bounding_box());
    assert(tmpl_img != NULL);

    // flip
    switch(g->get_orientation()) {
    case Gate::ORIENTATION_FLIPPED_UP_DOWN:
      flip_up_down<GateTemplateImage>(tmpl_img);
      break;
    case Gate::ORIENTATION_FLIPPED_LEFT_RIGHT:
      flip_left_right<GateTemplateImage>(tmpl_img);
      break;
    case Gate::ORIENTATION_FLIPPED_BOTH:
      flip_up_down<GateTemplateImage>(tmpl_img);
      flip_left_right<GateTemplateImage>(tmpl_img);
      break;
    default:
      // do nothing
      break;
    }

    images.push_back(tmpl_img);
  }

  GateTemplateImage_shptr merged_img = merge_images<GateTemplateImage>(images);

  tmpl->set_image(layer->get_layer_type(), merged_img);
}

Here is the caller graph for this function:

Merge images.

Parameters:
lmodel
gatesA set of objects. It can contain non-gate types too.

Definition at line 458 of file LogicModelHelper.cc.

References get_available_standard_layers(), and merge_gate_images().

                                                {

  /*
   * Classify gates by their standard cell object ID.
   */
  typedef std::map<object_id_t, std::list<Gate_shptr> > gate_sets_type;
  gate_sets_type gate_sets;

  BOOST_FOREACH(PlacedLogicModelObject_shptr plo, gates) {
    if(Gate_shptr gate = std::dynamic_pointer_cast<Gate>(plo)) {
      GateTemplate_shptr tmpl = gate->get_gate_template();
      if(tmpl) // ignore gates, that have no standard cell
        gate_sets[tmpl->get_object_id()].push_back(gate);
    }
  }

  /*
   * Iterate over layers.
   */

  BOOST_FOREACH(Layer_shptr layer, get_available_standard_layers(lmodel)) {

    /*
     * Iterate over standard cell classes.
     */
    for(gate_sets_type::iterator iter = gate_sets.begin(); iter != gate_sets.end(); ++iter) {

      Gate_shptr g = iter->second.front();
      assert(g != NULL);

      merge_gate_images(lmodel, layer, g->get_gate_template(), iter->second);
    }
  }

}

Here is the call graph for this function:

template<typename ImageType >
std::shared_ptr<ImageType> degate::merge_images ( std::list< std::shared_ptr< ImageType > > const &  images)

Merge a set of images by averaging them.

Exceptions:
DegateRuntimeExceptionThis exception is thrown, if images differ in size.
Returns:
If image collection images contains elements, this function returns a valid merged image. If the collection is empty, a NULL pointer is returned.

Definition at line 157 of file ImageHelper.h.

References MASK_A, MASK_B, MASK_G, MASK_R, and MERGE_CHANNELS.

Referenced by degate::ViaMatching::run().

                                                                                           {

    std::shared_ptr<ImageType> new_img;
    if(images.empty()) return new_img;

    const std::shared_ptr<ImageType> img = images.front();

    unsigned int w = img->get_width(), h = img->get_height();
    std::vector<double> i_tmp(4 * w * h);

    BOOST_FOREACH(const std::shared_ptr<ImageType> i, images) {

      // verify that all images have the same dimensions
      if(w != i->get_width() || h != i->get_height()) 
        throw DegateRuntimeException("merge_images() failed, because images differ in size.");

      for(unsigned int y = 0; y < h; y++)
      for(unsigned int x = 0; x < w; x++) {
        color_t pix = i->template get_pixel_as<color_t>(x, y);
        unsigned int offs = 4 * (y * w + x);
        i_tmp[offs] += MASK_R(pix);
        i_tmp[offs+1] += MASK_G(pix);
        i_tmp[offs+2] += MASK_B(pix);
        i_tmp[offs+3] += MASK_A(pix);
      }
    }

    const double elems = images.size();

    new_img = std::shared_ptr<ImageType>(new GateTemplateImage(w, h));
    assert(new_img != NULL);

    for(unsigned int y = 0; y < h; y++)
      for(unsigned int x = 0; x < w; x++) {
        unsigned int offs = 4 * (y * w + x);
        color_t pix = MERGE_CHANNELS(lround(i_tmp[offs] / elems),
                                     lround(i_tmp[offs+1] / elems),
                                     lround(i_tmp[offs+2] / elems),
                                     lround(i_tmp[offs+3] / elems));
        new_img->set_pixel(x, y, pix);
      }

    return new_img;
  }

Here is the caller graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::morphological_close ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
unsigned int  kernel_width = 3,
unsigned int  threshold_dilate = 1,
unsigned int  threshold_erode = 3 
)

Morphological close.

Definition at line 146 of file MorphologicalFilter.h.

References filter_image().

                                                             {

    filter_image<ImageTypeDst, ImageTypeSrc,
      DilateImagePolicy<ImageTypeSrc, typename ImageTypeSrc::pixel_type> >(dst, src, kernel_width, threshold_dilate);

    filter_image<ImageTypeDst, ImageTypeSrc,
      ErodeImagePolicy<ImageTypeSrc, typename ImageTypeSrc::pixel_type> >(dst, src, kernel_width, threshold_erode);

  }

Here is the call graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::morphological_open ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
unsigned int  kernel_width = 3,
unsigned int  threshold_dilate = 1,
unsigned int  threshold_erode = 3 
)

Morphological open.

Definition at line 128 of file MorphologicalFilter.h.

References filter_image().

                                                            {

    filter_image<ImageTypeDst, ImageTypeSrc,
      ErodeImagePolicy<ImageTypeSrc, typename ImageTypeSrc::pixel_type> >(dst, src, kernel_width, threshold_erode);

    filter_image<ImageTypeDst, ImageTypeSrc,
      DilateImagePolicy<ImageTypeSrc, typename ImageTypeSrc::pixel_type> >(dst, src, kernel_width, threshold_dilate);
  }

Here is the call graph for this function:

template<typename IntegerType >
IntegerType degate::next_power_of_two ( IntegerType  i)

Calculate the next higher power of two for a value i with i > 0.

Definition at line 34 of file DegateHelper.h.

                                               {
    IntegerType rval = 1;
    while(rval < i) rval <<= 1;
    return rval;
  }
template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::normalize ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
double  lower_bound = 0,
double  upper_bound = 1 
)

Normalize a single channel image.

Source and destination image can be the same image.

Definition at line 440 of file ImageManipulation.h.

                                                                 {

    assert_is_single_channel_image<ImageTypeSrc>();

    typename ImageTypeSrc::pixel_type src_min = get_minimum<ImageTypeSrc>(src);
    typename ImageTypeSrc::pixel_type src_max = get_maximum<ImageTypeSrc>(src);

    if(src_max - src_min == 0) return;

    double shift = -src_min;
    double factor = (double)(upper_bound - lower_bound) / (double)(src_max - src_min);

    /*
    std::cout
      << "lower bound: " << lower_bound << std::endl
      << "upper bound: " << upper_bound << std::endl
      << std::endl
      << "min val    : " << src_min << std::endl
      << "max val    : " << src_max << std::endl
      << std::endl
      << "factor     : " << factor << std::endl
      << std::endl
      ;
    */

    unsigned int h = std::min(src->get_height(), dst->get_height());
    unsigned int w = std::min(src->get_width(), dst->get_width());

    for(unsigned int y = 0; y < h; y++) {
      for(unsigned int x = 0; x < w; x++) {
        typename ImageTypeDst::pixel_type p =
          src->template get_pixel_as<typename ImageTypeDst::pixel_type>(x, y);

        double d = ((double)p + shift) * factor + lower_bound;
        if(d < lower_bound) {
          if(abs(lower_bound - d) < 0.001)
            d = lower_bound;
          std::cout << "transformed value "<< p << " beyond lower bound: " << d << std::endl;
          //d = lower_bound;
        }
        else if(d > upper_bound) {
          if(abs(d - upper_bound) < 0.001)
            d = upper_bound;
          std::cout << "transformed value "<< p << " beyond upper bound: " << d << std::endl;

        }
        assert(d >= lower_bound);
        assert(d <= upper_bound);
        dst->template set_pixel_as<double>(x, y, d);
      }
    }

  }
template<typename ImageType >
void degate::normalize ( std::shared_ptr< ImageType >  img,
double  lower_bound = 0,
double  upper_bound = 1 
)

Normalize a single channel image in place.

Definition at line 501 of file ImageManipulation.h.

                                                                 {
    normalize<ImageType, ImageType>(img, img, lower_bound, upper_bound);
  }
void degate::process_changelog_command ( LogicModel_shptr  lmodel,
transaction_id_t  transaction_id,
std::vector< xmlrpc_c::value > const &  command 
)

Parse an execute a command.

Exceptions:
XMLRPCExceptionThis exception is thrown, if commands cannot be parsed.

Definition at line 83 of file XmlRpc.cc.

References debug(), degate::Via::get_via_direction_from_string(), and TM.

Referenced by pull_changes_from_server().

                                                                                {

  debug(TM, "XMLRPC: process received command for transaction %d", transaction_id);

  if(lmodel->get_local_oid_for_roid(transaction_id) != 0) {
    debug(TM, "XMLRPC: transaction %d aready known.", transaction_id);
    return;
  }


  if(command.size() < 2) throw XMLRPCException("Command has not enough parameters.");

  if(command[0].type() != xmlrpc_c::value::TYPE_STRING)
    throw XMLRPCException("Command parameter is not a string");

  const std::string command_str = xmlrpc_c::value_string(command[0]);
  std::cout << " cmd: " << command_str << std::endl;

  if(!command_str.compare("remove")) {
    if(command.size() < 2)
      throw XMLRPCException("Command wire add has less then 8 parameters.");
    int ro_id = xmlrpc_c::value_int(command[1]);
    lmodel->remove_remote_object(ro_id);
  }

  else if( !command_str.compare("add")) {

    const std::string obj_type_str = xmlrpc_c::value_string(command[1]);

    if(!obj_type_str.compare("wire")) {
      if(command.size() < 8)
        throw XMLRPCException("Command wire add has less then 8 parameters.");

      int layer_id = xmlrpc_c::value_int(command[2]);
      int from_x = xmlrpc_c::value_int(command[3]);
      int from_y = xmlrpc_c::value_int(command[4]);
      int to_x = xmlrpc_c::value_int(command[5]);
      int to_y = xmlrpc_c::value_int(command[6]);
      unsigned int diameter = xmlrpc_c::value_int(command[7]);

      Wire_shptr w(new Wire(from_x, from_y, to_x, to_y, diameter));
      w->set_remote_object_id(transaction_id);
      Layer_shptr layer = lmodel->get_layer_by_id(layer_id);
      lmodel->add_object(layer, w);
    }
    else if(!obj_type_str.compare("via")) {
      if(command.size() < 7)
        throw XMLRPCException("Command via add has less then 8 parameters.");

      int layer_id = xmlrpc_c::value_int(command[2]);
      int x = xmlrpc_c::value_int(command[3]);
      int y = xmlrpc_c::value_int(command[4]);
      unsigned int diameter = xmlrpc_c::value_int(command[5]);
      const std::string direction = xmlrpc_c::value_string(command[6]);

      Via_shptr v(new Via(x, y, diameter, Via::get_via_direction_from_string(direction)));
      v->set_remote_object_id(transaction_id);
      Layer_shptr layer = lmodel->get_layer_by_id(layer_id);
      lmodel->add_object(layer, v);
    }
  }

  /*
  for(std::vector<xmlrpc_c::value>::const_iterator iter = command.begin();
      iter != command.end(); ++iter)
    std::cout << "\ttype " << (*iter).type() << std::endl;
  }
  */

}

Here is the call graph for this function:

Here is the caller graph for this function:

transaction_id_t degate::pull_changes_from_server ( std::string const &  server_url,
LogicModel_shptr  lmodel,
transaction_id_t  start_tid 
)

Pull objects from a remote server into the logic model.

Exceptions:
XMLRPCExceptionThis exception is thrown, if the XMLRPC fails for some reason.

Definition at line 156 of file XmlRpc.cc.

References debug(), process_changelog_command(), remote_method_call(), and TM.

                                                                              {
  try {
    xmlrpc_c::paramList params;
    params.add(xmlrpc_c::value_int(start_tid));
    xmlrpc_c::value_array ret(remote_method_call(server_url, "degate.pull", params));

    std::vector<xmlrpc_c::value> v(ret.vectorValueValue());

    if(start_tid == 0) ++start_tid;

    debug(TM, "Received %d changes since transaction %ld", v.size(), start_tid);

    unsigned int pos = 0;
    for(std::vector<xmlrpc_c::value>::const_iterator iter = v.begin();
        iter != v.end(); ++iter, pos++) {
      xmlrpc_c::value_array const& command(*iter);
      process_changelog_command(lmodel, start_tid + pos, command.vectorValueValue());

      /* If the process_changelog_command() fails with an exception, changes
         were already made to the logic model. That is no problem, because
         process_changelog_command() checks this case.
      */
    }

    return start_tid + v.size();
  }
  catch(XMLRPCException const& e) {
    throw;
  }
  catch(exception const& e) {
    cerr << "Client threw error: " << e.what() << endl;
    throw XMLRPCException(e.what());
  }
  catch(...) {
    cerr << "Client threw unexpected error." << endl;
    throw XMLRPCException("Client threw unexpected error.");
  }

  return start_tid;
}

Here is the call graph for this function:

void degate::push_changes_to_server ( std::string const &  server_url,
LogicModel_shptr  lmodel 
)

Push objects from the logic model to a remote server.

Definition at line 50 of file XmlRpc.cc.

References debug(), remote_method_call(), and TM.

                                                                                        {

  // iterate over gates
  for(LogicModel::object_collection::iterator iter = lmodel->objects_begin();
      iter != lmodel->objects_end(); ++iter) {

    object_id_t local_oid = iter->second->get_object_id();

    if(RemoteObject_shptr ro = std::dynamic_pointer_cast<RemoteObject>((*iter).second)) {

      if(!ro->has_remote_object_id()) {
        std::cout << "Push object to server." << std::endl;
        object_id_t remote_oid = ro->push(server_url);

        lmodel->update_roid_mapping(remote_oid, local_oid);
      }
    }
  }

  BOOST_FOREACH(object_id_t id, lmodel->get_removed_remote_objetcs_list()) {
    xmlrpc_c::paramList params;
    params.add(xmlrpc_c::value_string("remove"));
    params.add(xmlrpc_c::value_int(id));

    remote_method_call(server_url, "degate.push", params);

    debug(TM, "Send remove message for object with remote ID %d", id);
  }

  lmodel->reset_removed_remote_objetcs_list();
}

Here is the call graph for this function:

std::list< std::string > degate::read_directory ( std::string const &  path,
bool  prefix_path = false 
)

Read all entries from a directory, but not from subdirectories.

The path is expanded first with get_realpath().

Parameters:
pathThe directory you want to read.
prefix_pathControl whether you will get file names relative to path or absolute file names.
Returns:
Returns a list of strings containing files and subdirectory names. The special directory entires ".." and "." are not in the list.
See also:
get_realpath()

Definition at line 157 of file FileSystem.cc.

References get_realpath(), and join_pathes().

                                                                                 {

  DIR * dir = NULL;
  struct dirent * dir_ent = NULL;

  std::string rpth = get_realpath(path);

  if((dir = opendir(rpth.c_str())) == NULL)
    throw degate::FileSystemException(strerror(errno));

  std::list<std::string> retlist;

  while((dir_ent = readdir(dir)) != NULL)
    if(!(!strcmp(dir_ent->d_name, ".") ||
         !strcmp(dir_ent->d_name, "..")))

        retlist.push_back(prefix_path ? join_pathes(path, dir_ent->d_name) : dir_ent->d_name);

  closedir(dir);

  return retlist;
}

Here is the call graph for this function:

xmlrpc_c::value degate::remote_method_call ( std::string const &  server_url,
std::string const &  method_name,
xmlrpc_c::paramList const &  params 
)

Convinience method to call remote methods.

Definition at line 32 of file XmlRpc.cc.

Referenced by pull_changes_from_server(), push_changes_to_server(), degate::Wire::push_object_to_server(), degate::EMarker::push_object_to_server(), and degate::Via::push_object_to_server().

                                                                            {

  xmlrpc_c::clientXmlTransport_curl myTransport;
  xmlrpc_c::client_xml myClient(&myTransport);

  xmlrpc_c::rpcPtr myRpcP(method_name, params);
  xmlrpc_c::carriageParm_curl0 myCarriageParam(server_url);

  myRpcP->call(&myClient, &myCarriageParam);

  assert(myRpcP->isFinished());

  return myRpcP->getResult();
}

Here is the caller graph for this function:

void degate::remove_directory ( std::string const &  path)

Unlink a directory with all files in it.

Because this function is only for degate. We make some sanity checks.

Definition at line 127 of file FileSystem.cc.

Referenced by degate::ExternalMatching::run(), degate::Layer::unset_image(), and degate::StoragePolicy_Tile< PixelPolicy >::~StoragePolicy_Tile().

                                                   {
  boost::filesystem::path p(path);
  boost::filesystem::remove_all(path);
}

Here is the caller graph for this function:

Remove net from the logic model and remove it from all objects, which share a net.

Definition at line 496 of file LogicModelHelper.cc.

                                                                     {

  BOOST_FOREACH(object_id_t oid, *net) {
    PlacedLogicModelObject_shptr plo = lmodel->get_object(oid);
    assert(plo != NULL);
    if(ConnectedLogicModelObject_shptr clmo = 
       std::dynamic_pointer_cast<ConnectedLogicModelObject>(plo))
      clmo->remove_net();
  }
  
  lmodel->remove_net(net);
}
void degate::remove_file ( std::string const &  filename)

Unlink a file.

Definition at line 121 of file FileSystem.cc.

                                              {
  if(unlink(path.c_str()) != 0) {
    throw degate::FileSystemException(strerror(errno));
  }
}
double degate::rgba_to_hue ( rgba_pixel_t  p) [inline]

Convert an RGBA pixel to a hue value.

Definition at line 81 of file ImageManipulation.h.

References MASK_B, MASK_G, and MASK_R.

Referenced by degate::HueImageHistogram::add_area(), and degate::HueImageHistogram::get_for_rgb().

                                             {
     int red = MASK_R(p);
     int green = MASK_G(p);
     int blue = MASK_B(p);

     int max = std::max(red, std::max(green, blue));
     int min = std::min(red, std::min(green, blue));
     double delta = max - min;
     double h = 0;

     if(max == min) h = 0;
     else if(max == red) h = 60.0 *  (double)(green-blue)/delta;
     else if(max == green) h = 60.0 * (2.0 +(double)(blue-red)/delta);
     else if(max == blue) h = 60.0 * (4.0 + (double)(red-green)/delta);
     if(h < 0) h+=360;

     //h *= 255.0/360.0;
     return h;

   }

Here is the caller graph for this function:

double degate::rgba_to_lightness ( rgba_pixel_t  p) [inline]

Convert an RGBA pixel to a lightness value.

Definition at line 122 of file ImageManipulation.h.

References MASK_B, MASK_G, and MASK_R.

Referenced by degate::LightnessImageHistogram::add_area(), and degate::LightnessImageHistogram::get_for_rgb().

                                                   {
     int red = MASK_R(p);
     int green = MASK_G(p);
     int blue = MASK_B(p);

     return std::max(red, std::max(green, blue));
   }

Here is the caller graph for this function:

double degate::rgba_to_saturation ( rgba_pixel_t  p) [inline]

Convert an RGBA pixel to a saturation value.

Definition at line 106 of file ImageManipulation.h.

References MASK_B, MASK_G, and MASK_R.

Referenced by degate::SaturationImageHistogram::add_area(), and degate::SaturationImageHistogram::get_for_rgb().

                                                    {
     int red = MASK_R(p);
     int green = MASK_G(p);
     int blue = MASK_B(p);

     double max = std::max(red, std::max(green, blue));
     double min = std::min(red, std::min(green, blue));

     if(max == 0) return 0;
     else return (max - min) / max;
   }

Here is the caller graph for this function:

template<typename ImageType >
void degate::save_image ( std::string const &  path,
std::shared_ptr< ImageType >  img 
)

Store an image in a common file format.

Only the tiff file format is supported.

Todo:
We should use a factory for writer objects.
Exceptions:
DegateRuntimeExceptionThis exception is thrown, if the writer failed to save the image.
InvalidPointerExceptionThis exception is thrown, if parameter img represents an invalid pointer.

Definition at line 102 of file ImageHelper.h.

Referenced by degate::ViaMatching::run(), and save_part_of_image().

                                                                       {

    if(img == NULL) throw InvalidPointerException("invalid image pointer");
    TIFFWriter<ImageType> tiff_writer(img->get_width(),
                                      img->get_height(), path);
    if(tiff_writer.write_image(img) != true) {
      boost::format fmter("Error in save_image(): Cannot write file %1%.");
      fmter % path;
      throw DegateRuntimeException(fmter.str());
    }
  }

Here is the caller graph for this function:

template<typename ImageType >
void degate::save_normalized_image ( std::string const &  path,
std::shared_ptr< ImageType >  img 
)

Normalize a single channel image and store it in a common file format.

Only the tiff file format is supported.

Exceptions:
InvalidPointerExceptionThis exception is thrown, if parameter img represents an invalid pointer.

Definition at line 138 of file ImageHelper.h.

                                                                                  {

    if(img == NULL) throw InvalidPointerException("invalid image pointer");
    std::shared_ptr<ImageType> normalized_img(new ImageType(img->get_width(),
                                                                 img->get_height()));

    normalize<ImageType, ImageType>(normalized_img, img, 0, 255);

    save_image<ImageType>(path, normalized_img);
  }
template<typename ImageType >
void degate::save_part_of_image ( std::string const &  path,
std::shared_ptr< ImageType >  img,
BoundingBox const &  bounding_box 
)

Save a part of an image.

Exceptions:
InvalidPointerExceptionThis exception is thrown, if parameter img represents an invalid pointer.

Definition at line 119 of file ImageHelper.h.

References extract_partial_image(), degate::BoundingBox::get_height(), degate::BoundingBox::get_width(), and save_image().

Referenced by degate::ExternalMatching::run().

                                                           {

    if(img == NULL) throw InvalidPointerException("invalid image pointer");
    std::shared_ptr<ImageType> part(new ImageType(bounding_box.get_width(),
                                                       bounding_box.get_height()));

    extract_partial_image(part, img, bounding_box);
    save_image(path, part);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::scale_down_by_2 ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src 
)

Scale a source image down by factor 2.

You can scale images in place.

Definition at line 307 of file ImageManipulation.h.

References MASK_A, MASK_B, MASK_G, MASK_R, and MERGE_CHANNELS.

                                                        {


    unsigned int dst_x, dst_y, src_x, src_y;

    for(dst_y = 0; dst_y < dst->get_height(); dst_y++) {

      src_y = dst_y * 2;

      for(dst_x = 0; dst_x < dst->get_width(); dst_x++) {

        src_x = dst_x * 2;

        // 1 2
        // 3 4

        int i = 1;
        unsigned int r = 0, g = 0, b = 0, a = 0;

        rgba_pixel_t pix = src->template get_pixel_as<rgba_pixel_t>(src_x, src_y);
        r += MASK_R(pix);
        g += MASK_G(pix);
        b += MASK_B(pix);
        a += MASK_A(pix);

        if(src_x + 1 < src->get_width()) {
          pix = src->template get_pixel_as<rgba_pixel_t>(src_x + 1, src_y);
          i++;
          r += MASK_R(pix);
          g += MASK_G(pix);
          b += MASK_B(pix);
          a += MASK_A(pix);
        }

        if(src_y + 1 < src->get_height()) {
          pix = src->template get_pixel_as<rgba_pixel_t>(src_x, src_y + 1);
          i++;
          r += MASK_R(pix);
          g += MASK_G(pix);
          b += MASK_B(pix);
          a += MASK_A(pix);
        }

        if(src_x + 1 < src->get_width() && src_y + 1 < src->get_height()) {
          pix = src->template get_pixel_as<rgba_pixel_t>(src_x + 1, src_y + 1);
          i++;
          r += MASK_R(pix);
          g += MASK_G(pix);
          b += MASK_B(pix);
          a += MASK_A(pix);
        }

        r /= i;
        g /= i;
        b /= i;
        a /= i;

        dst->template set_pixel_as<rgba_pixel_t>(dst_x, dst_y, MERGE_CHANNELS(r, g, b, a));
      }
    }
  }
template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::scale_down_by_power_of_2 ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src 
)

Scale a source image down by factor 2.

Exceptions:
DegateRuntimeExceptionThis excpetion is thrown if the destination image has no dimension definition.

Definition at line 377 of file ImageManipulation.h.

Referenced by degate::TemplateMatching::prepare_template().

                                                                 {

    if(dst->get_width() == 0) throw DegateRuntimeException("Invalid image dimension for destination image.");

    unsigned int scaling = lrint((double)src->get_width() / (double)dst->get_width());

    if(scaling == 1)
      copy_image<ImageTypeDst, ImageTypeSrc>(dst, src);
    else if(scaling == 2)
      scale_down_by_2<ImageTypeDst, ImageTypeSrc>(dst, src);
    else {
      std::shared_ptr<ImageTypeDst> tmp(new ImageTypeDst(src->get_width(), src->get_height()));
      copy_image<ImageTypeDst, ImageTypeSrc>(tmp, src);

      scaling >>= 1;
      for(unsigned int i = 0; i < scaling - 1; i*=2) {
        scale_down_by_2<ImageTypeDst, ImageTypeDst>(tmp, tmp);
      }
      scale_down_by_2<ImageTypeDst, ImageTypeDst>(dst, tmp);
    }

  }

Here is the caller graph for this function:

template<typename PixelTypeSrc , typename ImageTypeDst >
void degate::set_pixel_as ( typename std::shared_ptr< ImageTypeDst >  img,
unsigned int  x,
unsigned int  y,
PixelTypeSrc  p 
) [inline]

Definition at line 193 of file ImageManipulation.h.

                                                                    {

    img->get_pixel(x, y, convert_pixel<typename ImageTypeDst::pixel_type, PixelTypeSrc>(p));
  }
template<typename T >
T degate::standard_deviation ( std::vector< T > const &  v) [inline]

Calculate the standard deviation of a vector.

Exceptions:
DegateRuntimeExceptionThis exception is thrown if vector's size is 0.

Definition at line 80 of file Statistics.h.

                                                     {

    if(v.empty())
      throw DegateRuntimeException("Error in standard_deviation(): The vector is empty.");

    T avg = average<T>(v);
    double sum = 0;
    for(typename std::vector<T>::const_iterator iter = v.begin(); iter != v.end(); ++iter)
      sum += pow(avg - *iter, 2);

    return sqrt(sum/(double)v.size());
  }
boost::filesystem::path degate::strip_path ( boost::filesystem::path const &  strip_from,
boost::filesystem::path const &  strip_what 
)

Strip the leading directory part from a path.

Parameters:
strip_fromIs the path.
strip_whatIs the base directory that should be removed.
Returns:
Returnes a new path with the base directory stripped.

Definition at line 352 of file FileSystem.cc.

Referenced by degate::ProjectArchiver::add_directory(), and degate::ProjectArchiver::add_single_file().

                                                                                  {

  path::iterator src_path_iter = strip_what.begin();
  path::iterator src_path_end = strip_what.end();
  path stripped;

  BOOST_FOREACH(path s, strip_from) {
    if(src_path_iter != src_path_end && *src_path_iter == s)
      ++src_path_iter;
    else
      stripped /= s;
  }

  return stripped;
}

Here is the caller graph for this function:

template<typename ImageType >
void degate::thinning ( std::shared_ptr< ImageType >  img)

Zhang-Suen-Thinning of an image.

Definition at line 233 of file MorphologicalFilter.h.

References zhang_suen_thinning_iteration().

                                              {
    assert_is_single_channel_image<ImageType>();

    bool running = true;

    do {
      running = zhang_suen_thinning_iteration(img, true);
      running = zhang_suen_thinning_iteration(img, false);
    }while(running);

  }

Here is the call graph for this function:

template<typename ImageTypeDst , typename ImageTypeSrc >
void degate::thresholding_image ( std::shared_ptr< ImageTypeDst >  dst,
std::shared_ptr< ImageTypeSrc >  src,
double  threshold 
)

Thresholding a single channel image.

Source and destination image can be the same image. The thresholding sets a pixel value to 0 if it is below the threshold or to a non-0 value if it is greater or equal than the trheshold.

Definition at line 513 of file ImageManipulation.h.

                                            {

    assert_is_single_channel_image<ImageTypeSrc>();

    unsigned int h = std::min(src->get_height(), dst->get_height());
    unsigned int w = std::min(src->get_width(), dst->get_width());

    for(unsigned int y = 0; y < h; y++) {
      for(unsigned int x = 0; x < w; x++) {
        typename ImageTypeDst::pixel_type p =
          src->template get_pixel_as<typename ImageTypeDst::pixel_type>(x, y);
        dst->template set_pixel_as<double>(x, y, p >= threshold ? 1 : 0);
      }
    }
  }
std::vector< std::string > degate::tokenize ( std::string const &  str)

Tokenize a string.

Parameters:
strThat is the string to tokenize, e.g. "hello world. \"foo bar"". This would result in three tokens.

Definition at line 16 of file DegateHelper.cc.

Referenced by degate::ExternalMatching::parse_line().

                                                          {

  /* This implementation is more or less directly derived from
     this posting http://www.gamedev.net/community/forums/topic.asp?topic_id=320087

  */
  vector<string> result;

  string          item;
  stringstream    ss(str);

  while(ss >> item){
    if (item[0]=='"') {
      int lastItemPosition = item.length() - 1;
      if (item[lastItemPosition]!='"') {
        // read the rest of the double-quoted item
        string restOfItem;
        getline(ss, restOfItem, '"');
        item += restOfItem;
      }
      // otherwise, we had a single word that was quoted. In any case, we now
      // have the item in quotes; remove them
      item = item.substr(1, lastItemPosition-1);
    }
    // item is "fully cooked" now
    result.push_back(item);
  }
  return result;
}

Here is the caller graph for this function:

Resize all gate ports from the logic model to the new size.

Definition at line 654 of file LogicModelHelper.cc.

                                                                               {

  // iterate over gates
  for(LogicModel::gate_collection::iterator iter = lmodel->gates_begin();
      iter != lmodel->gates_end(); ++iter) {
    Gate_shptr gate = (*iter).second;
    assert(gate != NULL);
    
    // iterate over gate ports
    for(Gate::port_iterator iter = gate->ports_begin();
        iter != gate->ports_end(); ++iter) {

      GatePort_shptr gate_port = *iter;
      if(gate_port->get_diameter() != new_size) {
        gate_port->set_diameter(new_size);
      }
    }
  }

}
void degate::write_string_to_file ( std::string const &  path,
std::string const &  content 
)

Write a string to a file.

Parameters:
pathPath to file.
contentThe file content.

Definition at line 60 of file DegateHelper.cc.

Referenced by degate::GateLibraryExporter::add_implementations(), and write_string_to_temp_file().

                                                            {

  std::ofstream file;
  file.open(path.c_str(), std::ios::trunc | std:: ios::out);
  file << content;
  file.close();
}

Here is the caller graph for this function:

std::string degate::write_string_to_temp_file ( std::string const &  dir,
std::string const &  content 
)

Write a string to a temp file.

Parameters:
dirThe directory, where the temp file should be created.
contentThe file content.
Returns:
Returns the temp file name including the directory part.

Definition at line 46 of file DegateHelper.cc.

References generate_temp_file_pattern(), and write_string_to_file().

                                                                        {

  char filename[PATH_MAX];
  std::string pattern = generate_temp_file_pattern(dir);
  strncpy(filename, pattern.c_str(), sizeof(filename));
  if(!mktemp(filename)) // should never return NULL
    throw DegateRuntimeException("mktemp() failed");

  write_string_to_file(filename, content);

  return filename;
}

Here is the call graph for this function:

template<typename ImageType >
bool degate::zhang_suen_thinning_iteration ( std::shared_ptr< ImageType >  img,
bool  condition_switch 
)

Helper function for the Zhang-Suen-Thinning.

Parameters:
imgThe image.
condition_switchIf true, the first condition set is checked. If false, the second condition set is checked.

Definition at line 168 of file MorphologicalFilter.h.

Referenced by thinning().

                                                            {
    assert_is_single_channel_image<ImageType>();

    bool running = false;
    unsigned int x, y;

    for(y = 1; y < img->get_height() - 1; y++) {
      for(x = 1; x < img->get_width() - 1; x++) {
        unsigned int
          p1 = img->get_pixel(x, y) > 0 ? 1 : 0;

        if(p1 > 0) {
          unsigned int
            p2 = img->get_pixel(x, y-1) > 0 ? 1 : 0,
            p3 = img->get_pixel(x+1, y-1) > 0 ? 1 : 0,
            p4 = img->get_pixel(x+1, y) > 0 ? 1 : 0,
            p5 = img->get_pixel(x+1, y+1) > 0 ? 1 : 0,
            p6 = img->get_pixel(x, y+1) > 0 ? 1 : 0,
            p7 = img->get_pixel(x-1, y+1) > 0 ? 1 : 0,
            p8 = img->get_pixel(x-1, y) > 0 ? 1 : 0,
            p9 = img->get_pixel(x-1, y-1)> 0 ? 1 : 0;

          unsigned int connectivity =
            (p2 == 0 && p3 == 1 ? 1 : 0) +
            (p3 == 0 && p4 == 1 ? 1 : 0) +
            (p4 == 0 && p5 == 1 ? 1 : 0) +
            (p5 == 0 && p6 == 1 ? 1 : 0) +
            (p6 == 0 && p7 == 1 ? 1 : 0) +
            (p7 == 0 && p8 == 1 ? 1 : 0) +
            (p8 == 0 && p9 == 1 ? 1 : 0) +
            (p9 == 0 && p2 == 1 ? 1 : 0);

          unsigned int non_zero_neighbors = p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9;


          if(2 <= non_zero_neighbors && non_zero_neighbors <= 6 &&
             connectivity == 1) {

            if(condition_switch == true) {

              if(p2 * p4 * p6 == 0 && p4 * p6 * p8 == 0) {
                img->set_pixel(x, y, 0);
                running = true;
              }
            }
            else {
              if(p2 * p4 * p8 == 0 && p2 * p6 * p8 == 0) {
                img->set_pixel(x, y, 0);
                running = true;
              }
            }
          }
        }

      }
    }

    return running;
  }

Here is the caller graph for this function: