/** * CNS is a true-shape nesting library that optimizes material usage. * * This header file is confidential and must not be distributed without * agreement of the authors. * * Authors: Nicolas Leignel and Renaud Lepere * Copyright: 2014-2023 */ #ifndef CNS_H #define CNS_H #ifdef __cplusplus extern "C" { #endif #ifdef CNS_WIN_DLL #define CNS_EXPORT __declspec(dll_export) #else #define CNS_EXPORT #endif #ifdef _WIN32 #define CNS_API __stdcall #else #define CNS_API #endif #ifdef __linux__ #include "cns_linux.h" #endif #ifdef __APPLE__ #include "cns_linux.h" #endif typedef struct CNS_LaunchingOrder * CNS_LaunchingOrderPtr; typedef struct CNS_Part * CNS_PartPtr; typedef struct CNS_Sheet * CNS_SheetPtr; typedef struct CNS_Computation * CNS_ComputationPtr; typedef struct CNS_Solution * CNS_SolutionPtr; typedef struct CNS_Nesting * CNS_NestingPtr; typedef enum { CNS_Ok = 0, CNS_BadPartGeometry = 1, CNS_TooComplexProblem = 2, CNS_CantContactServer = 3, CNS_CantGetSolution = 4, CNS_PendingComputation = 9, CNS_IntermediateResult = 10, CNS_NotAvailable = 11, CNS_CancelledComputation = 12, CNS_TerminatedComputation = 13, CNS_BadSheetGeometry = 14, CNS_BadSheetPrices = 15, CNS_BadCommonCutGaps = 16, CNS_PhysicalKeyNotFound = 17, CNS_IncompatibleFeatures = 18 } CNS_ComputationStatus; typedef enum { CNS_MinimizeXThenY = 0, // default CNS_MinimizeArea = 1, CNS_MinimizeYThenX = 2, CNS_IntelligentMinimizeX = 3, CNS_NoReusableOffcut = 4, // used for filling with optional parts/quantities CNS_IntelligentMinimizeY = 5, } CNS_Objective; typedef enum { CNS_BottomLeft = 0, // default, CNS_TopLeft = 1, CNS_BottomRight = 2, CNS_TopRight = 3 } CNS_Origin; typedef enum { CNS_Horizontal = 0, // default CNS_Vertical = 1 } CNS_GrainDirection; typedef enum { CNS_NoPreference = 0, CNS_LittlePreference = 1, CNS_NormalPreference = 2, CNS_StrongPreference = 3, CNS_AggressivePreference = 4 } CNS_MultiplicityPreference; typedef enum { CNS_FreeMixOnPart = 0, CNS_SingleOrientationAndRot180MixOnPart = 1, CNS_SingleOrientationMixOnPart = 2 } CNS_OrientationMixOnPart; /** * Basic structure used for describing part inputs. They can be composed of segments and arcs * called elements or simple polygons. */ typedef struct { double x; double y; double left_deflection; } CNS_Element; typedef struct { double x; double y; } CNS_Point; /* ===================================================================================== * * Creating launching order and describing inputs : parts, sheets... * * ===================================================================================== */ /** * Creates a new launching order. A launching order describes all the parts to nest, their * quantities and possible sheets. */ CNS_EXPORT CNS_LaunchingOrderPtr CNS_API CNS_NewLaunchingOrder(); /** * When finished, the launching order must be destroyed to free memory */ CNS_EXPORT void CNS_API CNS_DeleteLaunchingOrder(CNS_LaunchingOrderPtr); /** * Add a part in the given launching order. * * The parameter @param quantity describes the number of parts to nest. The quantity can be 0 * for filler parts in this case you must call CNS_AddOptionalQuantityToPart with a non null * optional quantity. * * The part has a simple external boundary described as an array of @param number_of_elements * elements. An element's coordinates, x and y, represents the end of the current element, its * origin is the end of the previous one. For the first element its origin is the x and y * coordinate of the last one. * * If the left_deflection is 0.0, the element is a segment, otherwise the element is an arc. It * represents the signed distance from the middle of the chord to the middle of the arc, so * left_deflection is positive if the arc goes clockwise. * * The material can be either on the left side or on the right side of the contour (it can be * clockwise or anticlockwise oriented). * * The contour can be self-intersecting, in this case the part is equivalent to its outer * boundary. * * Note 1: do not delete/free the part, it will be freed when calling CNS_DeleteLaunchingOrder. * */ CNS_EXPORT CNS_PartPtr CNS_API CNS_AddPart(CNS_LaunchingOrderPtr order, unsigned quantity, unsigned number_of_elements, const CNS_Element * elements); /** * Add a hole to the given part. * * The hole has @param number_of_elements elements and is described by a simple contour defined * by the the array @param elements. * * See: CNS_AddPart for description of the contour given the elements. */ CNS_EXPORT void CNS_API CNS_AddHoleToPart(CNS_PartPtr part, unsigned number_of_elements, const CNS_Element * elements); /** * Add another external boundary to the given part. Useful for pre-grouped parts. * * The boundary is described by @param number_of_elements elements and is described by the array * @param elements. * * See: CNS_AddPart for description of the contour given the elements. */ CNS_EXPORT void CNS_API CNS_AddExternalBoundaryToPart(CNS_PartPtr part, unsigned number_of_elements, const CNS_Element * elements); /** * Add an open cutting path to the given part. * * An open cutting path can be used to represent a lead-in, a lead-out or a free cut. No other * part will be nested on this cutting path. * * The path starts at the point @param origin and is composed of elements described by the * parameters @param number_of_elements and the array @param elements. The thickness of the path * must not be null. * * Note/Limitation: the current version retains a small gap of half the part gap around the open * cutting path. */ CNS_EXPORT void CNS_API CNS_AddOpenCuttingPathToPart(CNS_PartPtr part, CNS_Point origin, unsigned number_of_elements, const CNS_Element * elements, double thickness); /** * Add an optional quantity to the given part. * * Optional quantities are used to fill nestings in order to reduce waste and offcuts. * * By default, optional parts and optional quantities will be used to fill all the intermediate * sheets and the last sheet up to its limit (maximum X or Y depending upon the set * objective). This limit can be bypassed by the function CNS_SetFillLastNestingStrategy. */ CNS_EXPORT void CNS_API CNS_AddOptionalQuantityToPart(CNS_PartPtr part, unsigned optional_quantity); /** * Set an extra gap on the given part. * * Some parts may require additional spacing in order to protect them. * * Note: 2 adjacent nested parts with extra gaps will have an extra gap between them * corresponding to the sum of their extra gap. */ CNS_EXPORT void CNS_API CNS_SetExtraGapOnPart(CNS_PartPtr part, double extra_gap); /** * Set the filling mode for optional/filler parts in the last nesting. * * If @param fill_after_frontline is true then the optional parts will be nested even this leads * to increase the last sheet limit (maximum X or Y depending upon objective), otherwise * optional parts will not go past the end of the nest (default). */ CNS_EXPORT void CNS_API CNS_SetFillLastNestingStrategy(CNS_LaunchingOrderPtr order, int fill_after_frontline); /** * Add a polygon part in the given launching order. * * The parameter @param quantity describes the number of parts to nest. * * The part has a simple external boundary described as a polygon of @param number_of_points * points whose coordinates are described by the array @param points. * * The material can be either on the left side or on the right side of the polygon (it does not * matter if the polygon is defined clockwise or anticlockwise oriented). There is no need to * repeat the first point of polygon (but you can do it). The polygon can be self-intersecting, * in this case this is equivalent to the outer boundary of the self-intersecting polygon. * * Note: do not delete/free the part, it will be freed when calling CNS_DeleteLaunchingOrder. */ CNS_EXPORT CNS_PartPtr CNS_API CNS_AddPolygonPart(CNS_LaunchingOrderPtr order, unsigned quantity, unsigned number_of_points, const CNS_Point * points); /** * Add a polygonal hole to the given part. * * The hole have @param number_of_points points and is described by a simple polygon whose * coordinates are defined by the the array @param points. */ CNS_EXPORT void CNS_API CNS_AddPolygonHoleToPart(CNS_PartPtr part, unsigned number_of_points, const CNS_Point * points); /** * Add another external polygonal boundary to the given part. * * The boundary is described by @param number_of_points points and is described by a simple * polygon whose coordinates are defined by the the array @param points. */ CNS_EXPORT void CNS_API CNS_AddExternalPolygonBoundaryToPart(CNS_PartPtr part, unsigned number_of_points, const CNS_Point * points); /** * Shortcuts for creating rectangular and circular parts and holes. */ CNS_EXPORT CNS_PartPtr CNS_API CNS_AddRectangularPart(CNS_LaunchingOrderPtr order, unsigned quantity, double x1, double y1, double x2, double y2); CNS_EXPORT CNS_PartPtr CNS_API CNS_AddCircularPart(CNS_LaunchingOrderPtr order, unsigned quantity, double x, double y, double radius); CNS_EXPORT void CNS_API CNS_AddCircularHoleToPart(CNS_PartPtr part, double x, double y, double radius); CNS_EXPORT void CNS_API CNS_AddRectangularHoleToPart(CNS_PartPtr part, double x1, double y1, double x2, double y2); CNS_EXPORT void CNS_API CNS_AddCircularExternalBoundaryToPart(CNS_PartPtr part, double x, double y, double radius); CNS_EXPORT void CNS_API CNS_AddRectangularExternalBoundaryToPart(CNS_PartPtr part, double x1, double y1, double x2, double y2); /** * Specify authorizations on the given part. * * @param flip_allowed boolean means that we can flip the part about the x axis. * @param rotation boolean means that we can rotate the part. * @param rotation_step means the rotation steps in which we can rotate the part. * Set value of 0.0 to indicate free rotation (default). Value is in degrees. * * For example if rotation_step is 90, we can nest it in its 0, 90, 180, or 270 degree * orientations. * * Caution: do not use small values for rotation_step if part can be freely rotated, this can * degrade the algorithm performance. Use a value of 0.0 for free rotation instead. */ CNS_EXPORT void CNS_API CNS_SetPartAuthorizations(CNS_PartPtr part, int flip_allowed, int rotation, double rotation_step); /** * Set specific authorizations for the given part. * * Authorizations are a set of (flip, min_angle_in_degree, double max_angle_in_degree) and this * function must be be called several times to describe all those authorizations. * * Example: * CNS_AddPartSpecificAuthorizations(part, 0, 0.0, 0.0); * CNS_AddPartSpecificAuthorizations(part, 1, 180.0, 180.0); * means that the part can be either nested as it, or fliped and rotated at 180.0. * * Note: if max_angle_in_degree < min_angle_in_degree than 0.0 is included. * for example if min_angle_in_degree = 350 and max_angle_in_degree = 10 * then the part can only be tilted by 10deg around the normal orientation. * Note: calling this function override normal authorizations. */ CNS_EXPORT void CNS_API CNS_AddPartSpecificAuthorizations(CNS_PartPtr part, int flip, double min_angle_in_degree, double max_angle_in_degree); /** * Set the priority of the given part. * * If different part priorities are given, the most urgent ones (the ones with the smaller * value), will be nested first. * * Note 1: Parts with low priority will be nested if no higher priority parts can be nested, * this is useful to fill the holes. * * Note 2: If sheet priorities are also given, sheet priorities will be respected first. * * The default priority is 0. */ CNS_EXPORT void CNS_API CNS_SetPartPriority(CNS_PartPtr part, unsigned priority); /** * Set user string associated with the part. * This may be used for assigning an ID to each part. * * Note: the string is copied into the part object. */ CNS_EXPORT void CNS_API CNS_SetPartUserString(CNS_PartPtr part, const char * user_data); /** * Get user string associated with the part. * * Note: do not free/delete the returned string. */ CNS_EXPORT const char * CNS_API CNS_GetPartUserString(CNS_PartPtr part); /** * Copy the given part user_string to user_string with at most max_size character (from some * language binding limitations). */ CNS_EXPORT void CNS_API CNS_GetPartUserStringEx(CNS_PartPtr part, unsigned max_size, char * user_string); /** * Add a rectangular sheet to the given launching order. * * @param quantity is the number of sheet of the given dimension available. * @param x and @param y describes its dimensions. * * Note: do not delete/free the sheet, it will be freed when calling CNS_DeleteLaunchingOrder. */ CNS_EXPORT CNS_SheetPtr CNS_API CNS_AddSheet(CNS_LaunchingOrderPtr order, unsigned quantity, double x, double y); /** * Set user string associated to the sheet. * This may be used for assigning an ID to each sheet. * * Note: the string is copied into the sheet object. */ CNS_EXPORT void CNS_API CNS_SetSheetUserString(CNS_SheetPtr sheet, const char * user_data); /** * Set the grain direction of the sheet. * * If @param grain_direction is vertical then part authorizations are described relative to the * vertical direction. For example a part which can only be nested as is (no flip, no rotation) * can only be nested in rot90 authorization in a sheet with a vertical grain direction. */ CNS_EXPORT void CNS_API CNS_SetSheetGrainDirection(CNS_SheetPtr sheet, CNS_GrainDirection grain_direction); /** * Set the price of the sheet. * * The @param price is the price assigned to the given sheet. This price is used for global * optimization. If you set the price of one sheet, you have to give a price for all of the * sheets. The price must not be null. */ CNS_EXPORT void CNS_API CNS_SetSheetPrice(CNS_SheetPtr sheet, double price); /** * Add an irregular sheet to the given launching order. * * The sheet has a simple external boundary described by an array of @param number_of_elements * elements. * * The material can be either on the left side or on the right side of the polygon (the polygon * can be clockwise or anticlockwise oriented). * * Note 1: do not delete/free the sheet, it will be freed when calling CNS_DeleteLaunchingOrder. * * Note 2: there can be a small gap of half the part gap on internal side of the holes. * * See: CNS_AddPart for description of the contour given by @elements. */ CNS_EXPORT CNS_SheetPtr CNS_API CNS_AddNonRectangularSheet(CNS_LaunchingOrderPtr order, unsigned quantity, unsigned number_of_elements, const CNS_Element * elements); /** * Add a defect/hole to the given sheet. * * Parts will not be nested in the holes. * * The holes have @param number_of_elements elements and is described by the array @elements. * * Note 1: Coordinates of a rectangular sheet are between (0, 0) and (x, y), the holes must be * described in the same space. * * Note 2: there can be a small gap of half the part gap around the holes. * * See: CNS_AddPart for description of the contour given by @elements. */ CNS_EXPORT void CNS_API CNS_AddDefectToSheet(CNS_SheetPtr sheet, unsigned number_of_elements, const CNS_Element * elements); /** * Add another external boundary to the given sheet. * * The external boundary has @param number_of_elements elements and is described by the array * @elements. * * Note: this can also be used to add nestable areas inside defects/holes. */ CNS_EXPORT void CNS_API CNS_AddExternalBoundaryToSheet(CNS_SheetPtr sheet, unsigned number_of_elements, const CNS_Element * elements); /** * Add a defect/hole to the given sheet from an open line. * * The path starts at the point @param origin and is composed of elements described by the * parameters @param number_of_elements and the array @param elements. The thickness of the path * must not be null. */ CNS_EXPORT void CNS_API CNS_AddOpenDefectPathToSheet(CNS_SheetPtr sheet, CNS_Point origin, unsigned number_of_elements, const CNS_Element * elements, double thickness); /** * Helper to create defects equivalents to already nested parts. * * Creates a defect equivalent to the part geometry positioned at point (x, y), * possibly flipped and rotated from angle part_angle_deg. * Conventions for translation, flip, rotation is the same as the one * used in CNS_GetNestedPart (part is flipped first around x_axis, then rotated * around pivot point (0,0), then translated at point x, y to compute the geometry * of the defect). * Be aware that what is created from the part is pure defect geometry, which means : * this geometry is not taken into account into length or objective computation * this geometry is not taken into account in nested part quantity computing * this geomerty is not taken into account in constraint interaction with other parts * (multitorch, priority, common cut) */ CNS_EXPORT void CNS_API CNS_AddDefectFromNestedPart(CNS_SheetPtr sheet, CNS_PartPtr part, double x, double y, int part_flip, double part_angle_degree); // Polygonal sheet and defects CNS_EXPORT CNS_SheetPtr CNS_API CNS_AddNonRectangularPolygonSheet(CNS_LaunchingOrderPtr order, unsigned quantity, unsigned number_of_points, const CNS_Point * points); CNS_EXPORT void CNS_API CNS_AddPolygonDefectToSheet(CNS_SheetPtr sheet, unsigned number_of_points, const CNS_Point * points); CNS_EXPORT void CNS_API CNS_AddExternalPolygonBoundaryToSheet(CNS_SheetPtr sheet, unsigned number_of_points, const CNS_Point * points); /** * Set the priority of the given sheet. * * When nesting with multiple sheets it is possible to specify a sheet priority in order to * control which sheets will be nested first. Lower numbers indicate higher priority. * * If no priority is given or sheets have the same priorities, the optimizer will choose the * sheets in order to minimize material usage. * * The default priority is 0. */ CNS_EXPORT void CNS_API CNS_SetSheetPriority(CNS_SheetPtr sheet, unsigned priority); /** Set specific origin and objective for a given sheet. * * Some sheets can have specific origin or objective, you should use * CNS_SetOrigin and CNS_SetObjective for global setting. */ CNS_EXPORT void CNS_API CNS_SetSpecificSheetOrigin(CNS_SheetPtr sheet, CNS_Origin origin); CNS_EXPORT void CNS_API CNS_SetSpecificSheetObjective(CNS_SheetPtr sheet, CNS_Objective objective); /** * Get user string associated to the sheet. * * Note: do not free/delete the returned string. */ CNS_EXPORT const char * CNS_API CNS_GetSheetUserString(CNS_SheetPtr sheet); /** * Copy the given sheet user_string to user_string with at most max_size character (from some * language binding limitations). */ CNS_EXPORT void CNS_API CNS_GetSheetUserStringEx(CNS_SheetPtr sheet, unsigned max_size, char * user_string); /** * Add gaps around the sheet. Also known as edge spacing. * * For non rectangular sheet those gaps will be applied on bounding box edges. */ CNS_EXPORT void CNS_API CNS_SetSheetGaps(CNS_SheetPtr sheet, double left_gap, double right_gap, double bottom_gap, double top_gap); /** * When a sheet is not a rectangle, left, right, bottom, top gaps will be applied on * the sheet bounding box and irregular_border_gap will be applied on sheet geometry */ CNS_EXPORT void CNS_API CNS_SetNonRectangularSheetGaps(CNS_SheetPtr sheet, double left_gap, double right_gap, double bottom_gap, double top_gap, double irregular_border_gap); /** * Add gaps around defects/holes. * * Note: due to technical limitations, the gap around defects can be bigger than the specified * one when the defect gap is less than half of the spacing between parts ("Interpart gap"). */ CNS_EXPORT void CNS_API CNS_SetDefectGap(CNS_SheetPtr sheet, double gap); /** * Set the gap distance beween differents parts. */ CNS_EXPORT void CNS_API CNS_SetInterpartGap(CNS_LaunchingOrderPtr order, double gap); /** * Set the objective on the last sheet. * * CNS_MinimizeXThenY means that the optimizer will try to minimize x length giving less * importance to minimizing y length. * * CNS_MinimizeArea means that the optimizer will try to minimize the area of the bounding box * of the last sheet. * * CNS_IntelligentMininizeX minimize x if this does not lead to bad solution (long rectangular * part oriented so as to minimize x) */ CNS_EXPORT void CNS_API CNS_SetObjective(CNS_LaunchingOrderPtr order, CNS_Objective objective); /** * Set the origin of the nesting. * * Nested parts will be nested around the given origin. */ CNS_EXPORT void CNS_API CNS_SetOrigin(CNS_LaunchingOrderPtr order, CNS_Origin origin); /** * Preference for repeating nests in solution (as known as "multiplicity preference"). * * Favouring repeated nests may decrease the nesting efficiency but can lower production costs * due to reduction in preparation times and repeatability etc. */ CNS_EXPORT void CNS_API CNS_SetMultiplicityPreference(CNS_LaunchingOrderPtr order, CNS_MultiplicityPreference multiplicity_preference); /** * NoMixPreference * Preference for limiting the mix between differents kind of parts in the solution. * * If you have an important launching order with a large number of different parts and a large * quantity of each part, you may face solutions where all the parts are mixed in a lot of * different nestings. This may lead to difficulties when unloading parts. * * This function limits the number of active parts between nestings, it means that at the end of * a nesting only a limited number of parts are actives (a part is called active if some of them * were already cut before but some others remain to cut). This limitation can greatly improve * part unloading and this is noticeably important for automatic unloading systems and/or for * companies with limited shop floor space. * * @param max_number_of_active_parts is the maximum number of active parts, if 0 it means no * limits. * * Note 1: This constraint may decrease nesting performance. * Note 2: Under some special cases some small parts can be used to fill holes and the number of * active parts can be slighty above the maximum required. * Note 3: This function is not compatible with CNS_SetMultiplicityPreference. */ CNS_EXPORT void CNS_API CNS_SetNoMixPreference(CNS_LaunchingOrderPtr order, unsigned max_number_of_active_parts); /** * StrictNoMixPreferene * * This function is equivalent to CNS_SetNoMixPreference, however it does not have the * limitation of note 2, that small parts are used to fill holes. This will inforce the * limitation of @param max_number_of_active_parts number of active parts however this can * decrease even more nesting performace. */ CNS_EXPORT void CNS_API CNS_SetStrictNoMixPreference(CNS_LaunchingOrderPtr order, unsigned max_number_of_active_parts); /** * SetPartIgnoreStrictNoMixPreference * * This function is useful if SetStrictNoMixPreference is on, in this case some parts can be * flagged as ignore strict no mix preference. This means that they can be nested on all the * nestings. In this case, the max_number_of_active_parts is not respected for these parts. * * This is useful for unloadding systems where for instance small parts are not unloaded by the * robot where stacking space is limited but are unloaded into small boxes. */ CNS_EXPORT void CNS_API CNS_SetPartIgnoreStrictNoMixPreference(CNS_PartPtr part); /** * NoOrientationMixOnPart * Preference for limiting the orientation of a single part. * * If parts have a large number of quantities and have free rotations, it may lead to situations * where parts are nested in a lot of different orientations. For instance, this is problem in * sheet metal industry : the material is anisotropic and bending parts with different * orientations requires to modify properties on the bending machine. * * If a given part is marked as CNS_SingleOrientationAndRot180MixOnPart, then all of them will * be nested in the same orientation or the opposite orientation (central symmetry). * * If a given part is marked as CNS_SingleOrientationMixOnPart, then all of them will be nested * in the same orientation. This can be useful for PCB industry. * * Note 1: This is a strong constraint as it strongly limits freedom of parts so this can reduce * nesting performance. */ CNS_EXPORT void CNS_API CNS_SetNoOrientationMixOnPart(CNS_PartPtr part, CNS_OrientationMixOnPart orientation_mix_on_part); /** * SetSheetNoMixPreference * * Preference for limiting the number of different sheets when nesting with multiple sheet * possibilities. * * If multiple sheets are given to nest the parts, it may be needed to limit the number of * different sheet sizes in the solution. For instance, one can consider to nest all the * parts either using a machine with sheet sizes 4000x2000 or one with sheet sizes 3000x1500, * but to nest all the parts on the same machine. * * @max_number_of_different_sheets describes the maximum number of different sheet used in order * to do the nest. If this pararameter is 0 it means no limit. * * Note: This is a strong constraint as it limits freedom to choose sheets so this can reduce * nesting performance. */ CNS_EXPORT void CNS_API CNS_SetNoSheetMixPreference(CNS_LaunchingOrderPtr order, unsigned max_number_of_different_sheets); /** * Floating mode. * * Parts are nested such that a minimal gap (@see CNS_SetInterpartGap) between parts is * respected. However, sometimes a bigger gap may be used without degrading the results. Using * bigger gap can be better for heating and cutting constraints. * * This function enable a mode that increases the distance between parts, spreading them out * across the nest. * * For intermediate nestings in the solution, the whole sheet will be used to maximize the gap, * while for the last one the dimensions of the nesting will be kept constant. * * Note: Spreading out the parts in order to maximize the distance between parts is a time * consuming function. Therefore, this process will only be done on the last solution and may * take time. This time is not taken into account in the given computation time. * * Note: this mode is incompatible with common-cut, multi-flame and shear mode. */ CNS_EXPORT void CNS_API CNS_SetFloatingMode(CNS_LaunchingOrderPtr order, int enable); /** * Force origin packing mode. * * In very short time (few seconds), all parts may not be nested near the * origin due to timing constraint, this post optimization process force the * origin packing to be called at the end of the computation. It is called * only on the final solution and it can lead to a computation time a bit * longer (few seconds) than the given time. */ CNS_EXPORT void CNS_API CNS_SetOriginPackingMode(CNS_LaunchingOrderPtr order, int enable); /** * Advanced control of offcut value. * * Most of the time, there is a reusable offcut at the end of a multi-sheet launching order. * The value of this offcut must be evaluated correctly to obtain the best results especially if * different sheet sizes are available. Also, in case of a majority of large parts, it can be * possible to have reusable offcut for intermediate nesting. This function helps to have an * accurate evaluation of the offcuts. * * By default the value of this offcut is based on its area. This is a bit optimistic since in * real life, small offcuts can have no value and because there is labor cost associated to * managing offcuts. Also thin offcuts can be useless because it will be very hard to use it * again. Even the value of a big offcut on the last sheet cannot be considered to be * equivalent to its surface because we need to unload it before using it again so it can be * more convenient to use a smaller sheet even if the resultant material efficiency (fill-ratio) * is a bit worse. * * If the offcut is smaller than @param min_dimension in X or Y, its value is 0 because it is * too thin and will not be reusable. * * If the offcut area is smaller than @param min_area its value will be 0. If the offcut area is * greater than @param min_area the value will be based on the difference of area (by * continuity). * * For a reusable offcut, the value will be deprecated by @param unusable_ratio. This is useful * to generate a small offcut in a smaller sheet even if the fill-ratio considering that the * offcut is reusable. A small value between .1 and .3 is good. * * Note1: @param min_area must be in the same unit as @param min_dimension. If mm then it * must be mm^2. * * Note2: if @param_min_area is 0.0 and @param_min_distance is 0.0, an automatic value will be * used for interemdiate offcut to avoid considering that a very small offcut could have a * value. */ CNS_EXPORT void CNS_API CNS_SetOffcutEvaluation(CNS_LaunchingOrderPtr order, double min_dimension, double min_area, double unusable_ratio); /** * Control of part priorities. * * By default, priorities are not strict, if parts with high priority can not be nested a part with * a lower priorities will be nested. * In case of strict priorities, parts with lower priority will be nested only when all the parts of * higher priorities will have been nested. * * Note: this function may degrades the performance of the nesting. */ CNS_EXPORT void CNS_API CNS_SetStrictPrioritiesOnParts(CNS_LaunchingOrderPtr order, int strict); /** * Ignore priority on some parts. * * In strict priorities on part mode, some parts can be flagged as ignore to priority. This * means that they can be nested on all the nestings without considering them having a fixed * priority. */ CNS_EXPORT void CNS_API CNS_SetPartIgnorePriority(CNS_PartPtr part); /** * Control of part priorities position. * * By default, parts with high priority will be nested in the first sheets, * however they may not be nested near to the origin. This parameter enable to * nest high priority parts near to the origin. * * Note: this function may degrades the performance of the nesting. */ CNS_EXPORT void CNS_API CNS_SetOriginPrioritiesOnParts(CNS_LaunchingOrderPtr order, int enable); /* ===================================================================================== * * Launching nesting computation. * * ===================================================================================== */ /** * Launch a non-blocking computation of the given launching order. * * @param server the cloud nest server ip (or fully qualified name). * @param login the login used for running the computation. * @param computation_time the time you want to give to obtain the results (a longer time will * yield better results). * 30 seconds is the minimum advised time to obtain good results. * * Note: do not delete/free the computation, it will be freed when calling * CNS_DeleteLaunchingOrder. * * Note: the @param server can contains multiple servers separated by ";" for high availability. */ CNS_EXPORT CNS_ComputationPtr CNS_API CNS_LaunchComputation(CNS_LaunchingOrderPtr order, const char * server, const char * login, double computation_time); /** * Launch a non-blocking local computation of the given order. * * @param computation_time the time you want to give to obtain the results (a longer time will * yield better results). 30 seconds is the minimum advised time to obtain very good results. * * May not be available in the given version * * The computation can be launched in infinite mode by giving a computation time value of -1.0. * In this mode the user is responsible for collecting intermediate results and stopping the * engine himself with CNS_CancelComputation or CNS_TerminateComputation. * * Note: do not delete/free the computation, it will be freed when calling * CNS_DeleteLaunchingOrder. * * Note: this function launch an asynchronous computation and creates some working threads. */ CNS_EXPORT CNS_ComputationPtr CNS_API CNS_LaunchLocalComputation(CNS_LaunchingOrderPtr order, double computation_time); /** * Wait for the given computation to terminate and return the computation status. */ CNS_EXPORT CNS_ComputationStatus CNS_API CNS_WaitComputationTermination(CNS_ComputationPtr computation); CNS_EXPORT CNS_ComputationStatus CNS_API CNS_WaitNextSolution(CNS_ComputationPtr computation); /** * Return the status of the given computation. * * This function is non-blocking so we recommend you sleep the thread between calls in the loop. */ CNS_EXPORT CNS_ComputationStatus CNS_API CNS_GetComputationStatus(CNS_ComputationPtr computation); /** * Cancel the given computation without returning solution * * This function is blocking and may take a little time to execute (time to find a cancel * point), but it will stop as fast as possible even if no solution is computed. */ CNS_EXPORT CNS_ComputationStatus CNS_API CNS_CancelComputation(CNS_ComputationPtr computation); /** * Cancel all computations and delete the launching order in a detached thread. * * To cancel computation and return immediatly you can call the following function that will * cancel all the computations of the given launching order and delete the order immediately * after * * Note: This function encapsulates the cancellation and deletion in a detached thread so the * CPU can still be busy during a small time on very large problems. * * Note2: Do not use CNS_DeleteLaunchingOrder if this function is called. */ CNS_EXPORT void CNS_API CNS_AsyncCancelAllComputationsAndDeleteLaunchingOrder(CNS_LaunchingOrderPtr order); /** * Terminate the given computation with a valid optimized solution * * This function is blocking and may take a little time to execute (time to find a cancel * point), but it will stop as fast as possible and will return a valid and optimized solution. */ CNS_EXPORT CNS_ComputationStatus CNS_API CNS_TerminateComputation(CNS_ComputationPtr computation); /* ===================================================================================== * * Querying the results. * * ===================================================================================== */ /** * return the solution computed by the computation. * * precondition : Status of the computation must be CNS_Ok or CNS_IntermediateResult. * * Note: do not delete/free the solution, it will be freed when calling * CNS_DeleteLaunchingOrder. */ CNS_EXPORT CNS_SolutionPtr CNS_API CNS_GetSolution(CNS_ComputationPtr computation); /** * return the number of different nestings in the solution. */ CNS_EXPORT unsigned CNS_API CNS_GetNumberOfNestings(CNS_SolutionPtr solution); /** * return the nesting given @param nesting_number in the solution @param solution * * Note: do not delete/free the nesting, it will be freed when calling CNS_DeleteLaunchingOrder. */ CNS_EXPORT CNS_NestingPtr CNS_API CNS_GetNesting(CNS_SolutionPtr solution, unsigned nesting_number); /** * return the repeat count (or "multiplicity") of the given nesting. */ CNS_EXPORT unsigned CNS_API CNS_GetMultiplicity(CNS_NestingPtr nesting); /** * return the sheet used for the given nesting. */ CNS_EXPORT CNS_SheetPtr CNS_API CNS_GetSheet(CNS_NestingPtr nesting); /** * return the number of nested parts in the given nesting. */ CNS_EXPORT unsigned CNS_API CNS_GetNumberOfNestedParts(CNS_NestingPtr nesting); /** * Returns information of @param nested_part_number nested part in the given nesting * * @param x and @param y describe the position of the origin (0, 0) of the part's coordinates * @param flip if the part is fliped (first) * @param angle_in_deg, the angle of the nested part (rotated counter clockwise). * * If we take the part by (0, 0) this function return in @param x and @param y, the translation * required to move the original part into position. * * see illustration: images/pivot.svg * * For example if we nest 2 rectangles of dimensions 250x500 described by the coordinates (100, * 100), (350, 100), (350, 600), (100, 600), in a sheet of dimensions 2000x1000. We can nest * one part in (-100, -100) and this part will be in the bottom_left of the sheet, while the * second one will be nested at (-100,400) and the part will be in the top left of the sheet. * * The part can be also flipped and rotated around the (0, 0). For example, if we want to nest * the same two parts in a sheet of dimensions 2000x500 ; we can rotate the part by 90 counter * clock-wise, the coordinates will be (-100,100), (-100, 350), (-600, 350), (-600, 100). * * We can nest a first part at (600, -100) rotated by 90 and a second one at (1100, -100) * rotated by 90, to obtain a nesting of length 1000. */ CNS_EXPORT void CNS_API CNS_GetNestedPart(CNS_NestingPtr nesting, unsigned nested_part_number, CNS_PartPtr * part, double * x, double * y, int * flip, double * angle_in_deg); /** * return an invalid part. * * precondition : status of the computation must be CNS_BadPartGeometry. */ CNS_EXPORT CNS_PartPtr CNS_API CNS_GetPartWithBadGeometry(CNS_ComputationPtr computation); /** * Enable guillotine shear mode * * This is adapted from shear machines, that can only cut nesting from one border to another * either horizontaly or verticaly. This is suited for rectangular parts only., otherwise material * loss will occur. * * Limitations : this mode is incompatible with part priorities, filler parts, and also * non-rectangular sheets. * * If @param shear is not 0 then shear mode will be activated. */ CNS_EXPORT void CNS_API CNS_SetShearMode(CNS_LaunchingOrderPtr order, int shear); /** * Enable guillotine shear mode with rows patterns. */ CNS_EXPORT void CNS_API CNS_SetShearRowMode(CNS_LaunchingOrderPtr order, int shear); /** * Enable guillotine shear mode with columns patterns. */ CNS_EXPORT void CNS_API CNS_SetShearColumnMode(CNS_LaunchingOrderPtr order, int shear); /** * Set shear gap. * * When cutting with a shear machine or when cutting glass, it can be impossible to cut twice * within a small distance, the parameter @param shear_gap describes this distance. */ CNS_EXPORT void CNS_API CNS_SetShearGap(CNS_LaunchingOrderPtr order, double shear_gap); /** * Set maximum shear length. * * Some shear machines can have a limited size of maximum shear length. */ CNS_EXPORT void CNS_API CNS_SetShearMaxLength(CNS_LaunchingOrderPtr order, double shear_max_length); /** * Repulse parts from borders. * * For PCB nesting it is better to push parts far from borders to avoid cutting problems. */ CNS_EXPORT void CNS_API CNS_SetShearRepulseFromBorders(CNS_LaunchingOrderPtr order, int repulse); /* ===================================================================================== * * Common Line Nesting * * ===================================================================================== */ /** * Enable or disable common cut * * This function allows to enable common cut between identical parts. * * Note: common cut mode is currently exclusive from multitorch mode (and shear mode). */ CNS_EXPORT void CNS_API CNS_SetCommonCutMode(CNS_LaunchingOrderPtr launching_order, int enable, double common_cut_gap); /** * EXPERIMENTAL * Enable or disable common cut between different parts * * This experimental mode allows to generate common cut between different parts. * This function must be called instead of CNS_SetCommonCutMode in order to generate * nestings with common cut on different parts. * * This mode is useful if you have a large set of different parts with small quantities and long * straight edges that could be cut in common cut. In this case, this common cut mode allows * to save both cutting time and material. * * Note: this mode does not take into account limits given by functions * CNS_SetPartCommonCutMaxBlockSize */ CNS_EXPORT void CNS_API CNS_SetCommonCutDifferentPartMode(CNS_LaunchingOrderPtr order, int common_cut, double common_cut_gap); /** * Enable or disable common cut on a specific part. * * Some parts should never be cut in common line configurations. This function gives control to * enable or disable common line cutting on a part-by-part basis. */ CNS_EXPORT void CNS_API CNS_SetPartCommonCutMode(CNS_PartPtr part, int enable); /** * Enable or disable common cut with hole boundaries. * * In some circumstances it may be forbidden to nest in common cut with hole boundaries. By * default, it is allowed to do common cut with hole boundaries. */ CNS_EXPORT void CNS_API CNS_SetCommonCutOnHoles(CNS_LaunchingOrderPtr order, int common_cut_on_holes_boundary); /** * Controlling common line cutting safety. */ typedef enum { CNS_RestrictedCommonCut = 0, // only bi modules with very fast leaving conditions CNS_SafeCommonCut = 1, // fast leaving conditions on border of common cuts // (default) CNS_StrongCommnCut = 2, // intermediate CNS_AggressiveCommonCut = 3 // aggressive common cut (may lead to cutting problems) } CNS_CommonCutSafetyPreference; /** * Simple control of the quality of a common cut. * * see: CNS_SetCommonCutAuthorizations for finer control */ CNS_EXPORT void CNS_API CNS_SetCommonCutSafetyPreference(CNS_LaunchingOrderPtr launching_order, CNS_CommonCutSafetyPreference safety_preference); /** * Common cut leadin check. A small leadin check can be done on the extremities of common-cut to * obtain easy to cut common-cuts. */ typedef enum { CNS_FreeCommonCutLeadin = 0, // no leadin check CNS_LinearTangentialCommonCutLeadin = 1, // simple prolongating linear leadin (can be // tangential to one of the part) CNS_LinearSeparatingCommonCutLeadin = 2 // simple prolongating linear leadin is fully valid // and not on the border of any part. This will // forbid partial common cut. } CNS_CommonCutLeadin; /** * Advance common cut authorization control * * @param min_cutting_length the minimum length of a common cut. * @param max_regarding_ratio control the leaving condition. If the edges around a common cut * edge are nearer than the normal part_gap this may introduce heating or cut problems if two * edges remain close to each others during too much time. This "bad zone" is approximated by a * length called the "regarding length". The parameter @parameter max_regarding_ratio allows to * control the maximum length of the regarding_length relatively to the normal part gap. A value * of 2.0 is strict while a value of 8.0 is permissive. * @param leadin_type controls possible leading around the common_cut. This parameter allows to * check for a simple prolongating linear leadin around common cut edges, the length of the * leadin is equal to half the interpart gap. * @param no_holes do not introduce holes while doing common_cut * @param only do common cut by grouping 2 parts together */ CNS_EXPORT void CNS_API CNS_SetCommonCutAuthorizations(CNS_LaunchingOrderPtr launching_order, double min_cutting_length, double max_regarding_ratio, CNS_CommonCutLeadin leadin_type, int no_holes, int only_bi_module); /** * Perfect alignment of common cuts. * * It some cases, it is only possible to align same length and perfect alignment of common cuts. * This limits the number of possible common cuts. */ CNS_EXPORT void CNS_API CNS_SetCommonCutPerfectAlignment(CNS_LaunchingOrderPtr launching_order, int enable); /** * Common cut objective settings (favor common cut or material usage). */ /** * Control of the tradeoff between material and cutting time. * see: CNS_SetCommonCutObjective for more accurate control */ typedef enum { CNS_MaterialPreference = 0, // maximize material and give no specific value to // common-cutting CNS_WeakCuttingPreference = 1, // give some light preference for common-cutting // (default) CNS_AverageCuttingPreference = 2, // more preference for cutting CNS_StrongCuttingPreference = 3 // return solutions with lots of common line cutting // (may lose material) } CNS_CommonCutCuttingPreference; CNS_EXPORT void CNS_API CNS_SetCommonCutCuttingPreference(CNS_LaunchingOrderPtr launching_order, CNS_CommonCutCuttingPreference cutting_preference); /** * Give real material cost and cutting cost to obtain the best result (minimize cost). * * @param material_cost the cost of 1 unit of area of material (e.g. cost per mm^2) * @param cutting_cost the cost of 1 unit of cutting (e.g. cost per mm) * Cutting in common cut while reduce the cutting length by cutting 2 parts together. */ CNS_EXPORT void CNS_API CNS_SetCommonCutObjective(CNS_LaunchingOrderPtr launching_order, double material_cost, double cutting_cost); /** * Limit the size of common cut blocks to a maximum dimension. * * If parts are cut in common cut, this can lead to very big blocks. Those big blocks lead to * skeleton rigidity problems. It is possible to limit their maximum size. * @param max_block_size the maximum size of common cut block. */ CNS_EXPORT void CNS_API CNS_SetCommonCutMaxBlockSize(CNS_LaunchingOrderPtr launching_order, double max_block_size); /** * Limit the size of common cut blocks to a maximum dimension in x and in y. * * If parts are cut in common cut, this can lead to very big blocks. Those big blocks lead to * skeleton rigidity problems. It is possible to limit their maximum size. * @param max_block_size_x the maximum size of common cut block in x * @param max_block_size_y the maximum size of common cut block in y */ CNS_EXPORT void CNS_API CNS_SetCommonCutMaxBlockSizeXY(CNS_LaunchingOrderPtr launching_order, double max_block_size_x, double max_block_size_y); /** * Limit the size of common cut blocks to a maximum number of parts. * * If small parts are cut in common cut, this can lead to a huge number of * parts in a common cut block. If a cutting problem occurs, all the parts * can have a problem. This limit the maximum number of parts in a block. */ CNS_EXPORT void CNS_API CNS_SetPartCommonCutMaxBlockSize(CNS_PartPtr part, unsigned max_number_of_parts_in_block); /** * Allows to disable some advanced common cut checks. * * Warning: this can allows to generate small holes between common cuts. */ CNS_EXPORT void CNS_API CNS_SetCommonCutAdvancedQualityCheck(CNS_LaunchingOrderPtr order, int advanced_quality_check); /** * return the number of common cuts in the given nesting. */ CNS_EXPORT unsigned CNS_API CNS_GetNumberOfCommonCuts(CNS_NestingPtr nesting); typedef struct { double x_origin; double y_origin; double x_extremity; double y_extremity; } CNS_Segment; /** * Return informations associated to the given common_cut. * * This function returns the guessed common_cut in @param *common_cut, the indexes of the * nested_parts in @param *left_nested_part_index and in @param right_nested_part_index, and the * corresponding left and right segments in @param *left_segment and @param *right_segment. */ CNS_EXPORT void CNS_API CNS_GetCommonCut(CNS_NestingPtr nesting, unsigned common_cut_number, CNS_Segment * common_cut, unsigned * left_nested_part_index, CNS_Segment * left_segment, unsigned * right_nested_part_index, CNS_Segment * right_segment); /* ===================================================================================== * * Multi Torch Cutting * * ===================================================================================== */ /** * Enable or disable multi-torch and set basic multi-torch constraints. * max_torch_distance = 0.0 means no max_torch_distance; * * Note: multi torch mode is exclusive from common cut mode and shear mode * * Warning : beta version * Multi-torch mode is still in beta and some edge cases are not yet managed: * - For the moment multi-torch works only when trying to minimize x and nest on bottom in * last sheet. * Advanced mode and special offcuts are not managed * - Different kind of algorithms are used to produce multitorch result and the best results * are chosen automatically. For some specific geometries or situations new algorithms need * to be implemented to improve results but on average results are already ok. * - Multi-torch takes specific constraints such as min distance between torches and * auto or manual torch distance changes (e.g. during nesting on sheet or between sheets only). * Parameter vertical_torches_alignment should be true on most machines. For machines where * torches are aligned on the other axis, set it to false. * * These constraints are managed and results always take these constraints into account but * sometimes results may be suboptimal in terms of cutting time or used area * because specific algorithms are needed to handle complex situations. * * Feedback: If you find problems were results are clearly suboptimal compared to manual nesting * please report it so we can feed into the next round of development. */ CNS_EXPORT void CNS_API CNS_SetMultiTorchMode(CNS_LaunchingOrderPtr launching_order, int enable, int max_nb_torches, double min_torch_distance, double max_torch_distance, int vertical_torches_alignment); typedef enum { CNS_TorchWeakCuttingPreference = 1, // give some light preference for cutting time // vs losing material CNS_TorchAverageCuttingPreference = 2, // more preference for cutting time CNS_TorchStrongCuttingPreference = 3, // return solutions that strongly favor cutting // time CNS_TorchExtremeCuttingPreference = 4 //use multiple torches as much as possible // even at hight material cost } CNS_MultiTorchCuttingPreference; /** * Simple control of the tradeoff between material and cutting time. * * @param manual_torch_move indicates that the torch must be moved manually. In this case the * algorithm will reduce the number of times the gap between torches must be changed when * cutting a given plate. * * Note: Use either this function or CNS_SetMultiTorchObjective. If the two are called, only * last call will be taken into account * * see: CNS_SetMultiTorchObjective for more accurate control */ CNS_EXPORT void CNS_API CNS_SetMultiTorchCuttingPreference(CNS_LaunchingOrderPtr launching_order, CNS_MultiTorchCuttingPreference cutting_preference, int manual_torch_move); typedef enum { //Change torch distance inside a nesting as often as needed //usually because the change is done by the machine CN during the cut //equivalent to manual_torch_move = 0 CNS_TorchDistanceAutomatic = 0, //Change torch distance inside a nesting only //if it allows to cut more parts together CNS_TorchDistanceFewChanges = 1, //Try to find the best distance for cutting a nesting plate //and avoid changing torch distance inside a nesting, //usually because this operation is manual and takes time //equivalent to manual_torch_move = 1 CNS_TorchDistanceManual = 2, } CNS_MultiTorchTorchDistancePreference; CNS_EXPORT void CNS_API CNS_SetMultiTorchCuttingPreferenceDistancePreference(CNS_LaunchingOrderPtr launching_order, CNS_MultiTorchCuttingPreference cutting_preference, CNS_MultiTorchTorchDistancePreference distance_preference); /** * Advance control of the trade off between material, cutting time cost and moving torch cost * by giving real material cost and cutting time cost to obtain the best result (minimize cost). * * @param material_cost the cost of 1 unit of area of material (e.g. cost per mm^2) * @param cutting_cost the cost of time lost by cutting 1mm of material * @param torch_moving_cost the time cost of changing gap between torches while cutting a * plate. This operation may take time or not, depending on the machine (Sometimes the torch gap * can be controlled by the NC and sometimes the operator must change it manually). * * Note: Use either this function or CNS_SetMultiTorchCuttingPreference. If the two are called, * only last call will be taken into account */ CNS_EXPORT void CNS_API CNS_SetMultiTorchObjective(CNS_LaunchingOrderPtr launching_order, double material_cost, double cutting_time_cost, int torches_can_move, double torch_moving_cost); /** * Another way to define the tradeoff between material and cutting cost by giving machine speed * and hourly cost rate of the machine when cutting. * * @param material_cost the cost of 1 unit of area of material (e.g. cost per mm^2) * @param single_torch_cost_per_hour is hourly rate of the machine when cutting with one torch * @param extra_torch_cost_per_hour is extra hourly rate when cutting with an extra torch * So hourly rate of the machine when cutting with 3 torches is single_torch_cost_per_hour + 2 * * extra_torch_cost_per_hour. * @param mm_per_hour_machine_cutting_speed for describing maching cutting speed * @param torch_can_move describes if torches gap can be moved in a nesting * @param torch_moving_cost is the cost of changing gap between torches. This operation may take * time or not, depending on the machine (Sometimes the torch gap can be controlled by the NC * and sometimes the operator must change it manually). * * Use this instead of CNS_SetMultiTorchCuttingPreference if you prefer. */ CNS_EXPORT void CNS_API CNS_SetDetailedMultiTorchObjective(CNS_LaunchingOrderPtr launching_order, double material_cost, double single_torch_cost_per_hour, double extra_torch_cost_per_hour, double mm_per_hour_machine_cutting_speed, int torches_can_move, double torch_moving_cost); /** * Get multitorch infos for each part of the given nesting. * * There are three kinds of multitorch infos : * - the group_number is the same for all parts that must be cut at the same time. * - For parts that have the same group number, all torch_numbers are different. * On a given part the torch number indicates what torch is cutting the part. The group * always has a part that has torch number 0 that is the bottom part of the group. * - torch distance indicates how the torch are set up. A distance of 400mm on a 4 torches * system indicates that torches positions are 0, 400, 800, 1200. For parts of the same group * the distance is always the same. * Parts in group -1 are standalone parts. * Part_index is the index of the part in the nesting, from 0 to (nb_nested_parts - 1) * * An example : you have nested parts A1 (100, 100), A2(100, 200), A3(100,300), A4(100, 400), * A5(100,500) B1(200,100) B2(200, 350), C(200,500), D(200,600) in the same nesting on a 3 * torches system with a minimum distance of 150 between torches. You will cut {A1,A3,A5} * together, {A2, A4} together and {B1, B2} together. C and D are standalone You will get the * following (group_number, torch_number, torch_distance) values for each part : A1 (0,0,200.0), * A2 (1,0,200.0), A3(0,1,200.0), A4(1,1,200.0), A5(0,2,200.0), B1(2,0,250.0), B2(2,1,250.0), * C(-1,0,0.0), D(-1,0,0.0) */ CNS_EXPORT void CNS_API CNS_GetPartTorchInfos(CNS_NestingPtr nesting, unsigned part_index, int * group_number, unsigned * torch_number, double * torch_distance); /** * Renest the holes in order to ensure that the holes with the same parts are nested the same * way. * * In some particular case such as micro-attached parts with automatic unloading system, it may * be useful that the holes with the same parts are nested exactly the same way in order to * unload the nested parts on the same stack. */ CNS_EXPORT void CNS_API CNS_SetHoleRenester(CNS_LaunchingOrderPtr launching_order, int hole_renester_enable); /* ===================================================================================== * * Statistics * * ===================================================================================== */ /** * Return the fill ratio of the solution. * * Note that the fill ratio may not be strictly decreasing in intermediate solutions because some * value is given to minimize the number of nestings, to reusable intermediate sheets, to * pushing the parts in corners and to cutting costs. */ CNS_EXPORT double CNS_API CNS_GetFillRatio(CNS_SolutionPtr solution); /** * Return dimensions of the nesting. * This function return in *x and in *y the dimensions of the nesting (relatively to its origin). */ CNS_EXPORT void CNS_API CNS_GetNestingDimensions(CNS_NestingPtr nesting, double * x, double * y); /** * Return the fill ratio of the given nesting. * * For the last sheet the considered used surface in the fill ratio is up to the frontline, or area. */ CNS_EXPORT double CNS_API CNS_GetNestingFillRatio(CNS_NestingPtr nesting); /* ===================================================================================== * * Debug and html drawing * * ===================================================================================== */ /** * Generate an html report of the inputs (parts, sheets...). * * This function is useful to check if the inputs are corrects. */ CNS_EXPORT void CNS_API CNS_GenerateHtmlLaunchingOrderReport(CNS_LaunchingOrderPtr launching_order, const char * filename); /** * Generate an html report for the given solution. */ CNS_EXPORT void CNS_API CNS_GenerateHtmlSolutionReport(CNS_SolutionPtr solution, const char * filename); /** * Generate DXF file for the corresponding nesting. */ CNS_EXPORT void CNS_API CNS_GenerateDxfNesting(CNS_NestingPtr nesting, const char * filename); /** * Generate a json problem description. * * This function is useful to report problem descriptions. This allow us to reproduce the * nesting problem and run it. */ CNS_EXPORT void CNS_API CNS_GenerateLaunchingOrderProblem(CNS_LaunchingOrderPtr launching_order, const char * filename); /** * Some functionalities may be activated only by calling this unlock key function */ CNS_EXPORT void CNS_API CNS_UnLockLaunchingOrder(CNS_LaunchingOrderPtr launching_order, unsigned unlock_key); /** * Return informations about the current build. */ CNS_EXPORT const char * CNS_API CNS_GetMajorVersion(); CNS_EXPORT const char * CNS_API CNS_GetBuildDate(); CNS_EXPORT const char * CNS_API CNS_GetBuildVersion(); CNS_EXPORT const char * CNS_API CNS_GetBuildVersionNumber(); #ifdef __cplusplus } #endif #endif