#include <base_units.h>
#include <board_commit.h>
#include <board_design_settings.h>
#include <pad.h>
#include <fp_shape.h>
#include <footprint.h>
#include <confirm.h>
#include <dialogs/dialog_text_entry.h>
#include <geometry/geometry_utils.h>
#include <math/util.h>
#include <microwave/microwave_tool.h>
#include <tool/tool_manager.h>
#include <tools/pcb_actions.h>
#include <pcb_edit_frame.h>
#include <validators.h>

Macros
#define	ADJUST_SIZE 0.988

Enumerations
enum	INDUCTOR_S_SHAPE_RESULT { INDUCTOR_S_SHAPE_RESULT::OK, INDUCTOR_S_SHAPE_RESULT::TOO_LONG, INDUCTOR_S_SHAPE_RESULT::TOO_SHORT, INDUCTOR_S_SHAPE_RESULT::NO_REPR }

Functions
static void	gen_arc (std::vector< wxPoint > &aBuffer, const wxPoint &aStartPoint, const wxPoint &aCenter, int a_ArcAngle)
	Function gen_arc generates an arc using arc approximation by lines: Center aCenter Angle "angle" (in 0.1 deg) More...

static INDUCTOR_S_SHAPE_RESULT	BuildCornersList_S_Shape (std::vector< wxPoint > &aBuffer, const wxPoint &aStartPoint, const wxPoint &aEndPoint, int aLength, int aWidth)
	Function BuildCornersList_S_Shape Create a path like a S-shaped coil. More...

Macro Definition Documentation

◆ ADJUST_SIZE

#define ADJUST_SIZE 0.988

Enumeration Type Documentation

◆ INDUCTOR_S_SHAPE_RESULT

enum INDUCTOR_S_SHAPE_RESULT

strong

Enumerator
OK
TOO_LONG	S-shape constructed.
TOO_SHORT	Requested length too long.
NO_REPR	Requested length too short.

Definition at line 79 of file microwave_inductor.cpp.

 {
     OK,        
     TOO_LONG,  
     TOO_SHORT, 
     NO_REPR,   
 };

Function Documentation

◆ BuildCornersList_S_Shape()

static INDUCTOR_S_SHAPE_RESULT BuildCornersList_S_Shape	(	std::vector< wxPoint > &	aBuffer,
		const wxPoint &	aStartPoint,
		const wxPoint &	aEndPoint,
		int	aLength,
		int	aWidth
	)

static

Function BuildCornersList_S_Shape Create a path like a S-shaped coil.

Parameters

aBuffer	= a buffer where to store points (ends of segments)
aStartPoint	= starting point of the path
aEndPoint	= ending point of the path
aLength	= full length of the path
aWidth	= segment width

Definition at line 97 of file microwave_inductor.cpp.

 {
 /* We must determine:
  * segm_count = number of segments perpendicular to the direction
  * segm_len = length of a strand
  * radius = radius of rounded parts of the coil
  * stubs_len = length of the 2 stubs( segments parallel to the direction)
  *         connecting the start point to the start point of the S shape
  *         and the ending point to the end point of the S shape
  * The equations are (assuming the area size of the entire shape is Size:
  * Size.x = 2 * radius + segm_len
  * Size.y = (segm_count + 2 ) * 2 * radius + 2 * stubs_len
  * aInductorPattern.m_length = 2 * delta // connections to the coil
  *             + (segm_count-2) * segm_len      // length of the strands except 1st and last
  *             + (segm_count) * (PI * radius)   // length of rounded
  * segm_len + / 2 - radius * 2)                 // length of 1st and last bit
  *
  * The constraints are:
  * segm_count >= 2
  * radius < m_Size.x
  * Size.y = (radius * 4) + (2 * stubs_len)
  * segm_len > radius * 2
  *
  * The calculation is conducted in the following way:
  * first:
  * segm_count = 2
  * radius = 4 * Size.x (arbitrarily fixed value)
  * Then:
  * Increasing the number of segments to the desired length
  * (radius decreases if necessary)
  */
     wxPoint size;
 
     // This scale factor adjusts the arc length to handle
     // the arc to segment approximation.
     // because we use SEGM_COUNT_PER_360DEG segment to approximate a circle,
     // the trace len must be corrected when calculated using arcs
     // this factor adjust calculations and must be changed if SEGM_COUNT_PER_360DEG is modified
     // because trace using segment is shorter the corresponding arc
     // ADJUST_SIZE is the ratio between tline len and the arc len for an arc
     // of 360/ADJUST_SIZE angle
     #define ADJUST_SIZE 0.988
 
     auto    pt       = aEndPoint - aStartPoint;
     double  angle    = -ArcTangente( pt.y, pt.x );
     int     min_len  = KiROUND( EuclideanNorm( pt ) );
     int     segm_len = 0;           // length of segments
     int     full_len;               // full len of shape (sum of length of all segments + arcs)
 
 
     /* Note: calculations are made for a vertical coil (more easy calculations)
      * and after points are rotated to their actual position
      * So the main direction is the Y axis.
      * the 2 stubs are on the Y axis
      * the others segments are parallel to the X axis.
      */
 
     // Calculate the size of area (for a vertical shape)
     size.x = min_len / 2;
     size.y = min_len;
 
     // Choose a reasonable starting value for the radius of the arcs.
     int radius = std::min( aWidth * 5, size.x / 4 );
 
     int segm_count;     // number of full len segments
                         // the half size segments (first and last segment) are not counted here
     int stubs_len = 0;  // length of first or last segment (half size of others segments)
 
     for( segm_count = 0; ; segm_count++ )
     {
         stubs_len = ( size.y - ( radius * 2 * (segm_count + 2 ) ) ) / 2;
 
         if( stubs_len < size.y / 10 ) // Reduce radius.
         {
             stubs_len = size.y / 10;
             radius    = ( size.y - (2 * stubs_len) ) / ( 2 * (segm_count + 2) );
 
             if( radius < aWidth ) // Radius too small.
             {
                 // Unable to create line: Requested length value is too large for room
                 return INDUCTOR_S_SHAPE_RESULT::TOO_LONG;
             }
         }
 
         segm_len  = size.x - ( radius * 2 );
         full_len  = 2 * stubs_len;               // Length of coil connections.
         full_len += segm_len * segm_count;       // Length of full length segments.
         full_len += KiROUND( ( segm_count + 2 ) * M_PI * ADJUST_SIZE * radius );    // Ard arcs len
         full_len += segm_len - (2 * radius);     // Length of first and last segments
                                                  // (half size segments len = segm_len/2 - radius).
 
         if( full_len >= aLength )
             break;
     }
 
     // Adjust len by adjusting segm_len:
     int delta_size = full_len - aLength;
 
     // reduce len of the segm_count segments + 2 half size segments (= 1 full size segment)
     segm_len -= delta_size / (segm_count + 1);
 
     // at this point, it could still be that the requested length is too
     // short (because 4 quarter-circles are too long)
     // to fix this is a relatively complex numerical problem which probably
     // needs a refactor in this area. For now, just reject these cases:
     {
         const int min_total_length = 2 * stubs_len + 2 * M_PI * ADJUST_SIZE * radius;
         if( min_total_length > aLength )
         {
             // we can't express this inductor with 90-deg arcs of this radius
             return INDUCTOR_S_SHAPE_RESULT::TOO_SHORT;
         }
     }
 
     if( segm_len - 2 * radius < 0 )
     {
         // we can't represent this exact requested length with this number
         // of segments (using the current algorithm). This stems from when
         // you add a segment, you also add another half-circle, so there's a
         // little bit of "dead" space.
         // It's a bit ugly to just reject the input, as it might be possible
         // to tweak the radius, but, again, that probably needs a refactor.
         return INDUCTOR_S_SHAPE_RESULT::NO_REPR;
     }
 
     // Generate first line (the first stub) and first arc (90 deg arc)
     pt = aStartPoint;
     aBuffer.push_back( pt );
     pt.y += stubs_len;
     aBuffer.push_back( pt );
 
     auto centre = pt;
     centre.x -= radius;
     gen_arc( aBuffer, pt, centre, -900 );
     pt = aBuffer.back();
 
     int half_size_seg_len = segm_len / 2 - radius;
 
     if( half_size_seg_len )
     {
         pt.x -= half_size_seg_len;
         aBuffer.push_back( pt );
     }
 
     // Create shape.
     int ii;
     int sign = 1;
     segm_count += 1;    // increase segm_count to create the last half_size segment
 
     for( ii = 0; ii < segm_count; ii++ )
     {
         int arc_angle;
 
         if( ii & 1 ) // odd order arcs are greater than 0
             sign = -1;
         else
             sign = 1;
 
         arc_angle = 1800 * sign;
         centre    = pt;
         centre.y += radius;
         gen_arc( aBuffer, pt, centre, arc_angle );
         pt    = aBuffer.back();
         pt.x += segm_len * sign;
         aBuffer.push_back( pt );
     }
 
     // The last point is false:
     // it is the end of a full size segment, but must be
     // the end of the second half_size segment. Change it.
     sign *= -1;
     aBuffer.back().x = aStartPoint.x + radius * sign;
 
     // create last arc
     pt        = aBuffer.back();
     centre    = pt;
     centre.y += radius;
     gen_arc( aBuffer, pt, centre, 900 * sign );
 
     // Rotate point
     angle += 900;
 
     for( unsigned jj = 0; jj < aBuffer.size(); jj++ )
     {
         RotatePoint( &aBuffer[jj], aStartPoint, angle );
     }
 
     // push last point (end point)
     aBuffer.push_back( aEndPoint );
 
     return INDUCTOR_S_SHAPE_RESULT::OK;
 }

References ADJUST_SIZE, PNS::angle(), ArcTangente(), EuclideanNorm(), gen_arc(), KiROUND(), NO_REPR, OK, RotatePoint(), sign(), TOO_LONG, and TOO_SHORT.

Referenced by MICROWAVE_TOOL::createMicrowaveInductor().

◆ gen_arc()

static void gen_arc	(	std::vector< wxPoint > &	aBuffer,
		const wxPoint &	aStartPoint,
		const wxPoint &	aCenter,
		int	a_ArcAngle
	)

static

Function gen_arc generates an arc using arc approximation by lines: Center aCenter Angle "angle" (in 0.1 deg)

Parameters

aBuffer	= a buffer to store points.
aStartPoint	= starting point of arc.
aCenter	= arc centre.
a_ArcAngle	= arc length in 0.1 degrees.

Definition at line 50 of file microwave_inductor.cpp.

 {
     auto first_point = aStartPoint - aCenter;
     auto radius = KiROUND( EuclideanNorm( first_point ) );
     int  seg_count = GetArcToSegmentCount( radius, ARC_HIGH_DEF, a_ArcAngle / 10.0 );
 
     double increment_angle = (double) a_ArcAngle * M_PI / 1800 / seg_count;
 
     // Creates nb_seg point to approximate arc by segments:
     for( int ii = 1; ii <= seg_count; ii++ )
     {
         double  rot_angle = increment_angle * ii;
         double  fcos = cos( rot_angle );
         double  fsin = sin( rot_angle );
         wxPoint currpt;
 
         // Rotate current point:
         currpt.x = KiROUND( ( first_point.x * fcos + first_point.y * fsin ) );
         currpt.y = KiROUND( ( first_point.y * fcos - first_point.x * fsin ) );
 
         auto corner = aCenter + currpt;
         aBuffer.push_back( corner );
     }
 }

References EuclideanNorm(), GetArcToSegmentCount(), and KiROUND().

Referenced by BuildCornersList_S_Shape().

Macros

Enumerations