minsky::Wire Class Reference

#include <wire.h>

Inheritance diagram for minsky::Wire:

Collaboration diagram for minsky::Wire:

Public Member Functions
	Wire ()
	Wire (const std::weak_ptr< Port > &from, const std::weak_ptr< Port > &to, const std::vector< float > &a_coords=std::vector< float >())
	~Wire ()
std::shared_ptr< Port >	from () const
std::shared_ptr< Port >	to () const
void	moveToPorts (const std::shared_ptr< Port > &from, const std::shared_ptr< Port > &to)
	switch ports this wire links to More...
void	storeCairoCoords (cairo_t *cairo) const
	stash all the internal cairo coordinates along a wire More...
void	draw (cairo_t *cairo, bool reverseArrow=false) const
	draw this item into a cairo context More...
std::vector< float >	coords () const
	display coordinates More...
std::vector< float >	coords (const std::vector< float > &coords)
bool	near (float x, float y) const
	returns true if coordinates are near this wire More...
unsigned	nearestHandle (float x, float y)
	returns the index into the coordinate list if x,y is close to it. Otherwise inserts midpoints and returns that. Wire endpoints are not returned More...
void	insertHandle (unsigned position, float x, float y)
void	deleteHandle (float x, float y)
void	editHandle (unsigned position, float x, float y)
void	straighten ()
bool	visible () const
	whether this wire is visible or not More...
void	moveIntoGroup (Group &dest)
	move this from its group into dest More...
void	split ()
	splits wires crossing group boundaries More...
Units	units (bool) const
	units (dimensional analysis) of data flowing across wire More...
Public Member Functions inherited from minsky::NoteBase
virtual std::string const &	detailedText () const
virtual std::string const &	detailedText (const std::string &x)
virtual std::string const &	tooltip () const
virtual std::string const &	tooltip (const std::string &x)
virtual void	adjustBookmark () const
	adjust bookmark list to reflect current configuration More...
virtual void	updateBoundingBox ()
virtual	~NoteBase ()=default
Public Member Functions inherited from minsky::WireAccessor
	WireAccessor ()

Private Member Functions
	CLASSDESC_ACCESS (Wire)

Private Attributes
std::vector< float >	m_coords
std::weak_ptr< Port >	m_from
	ports this wire connects More...
std::weak_ptr< Port >	m_to
int	unitsCtr =0
	for detecting wiring loops in units() More...
std::vector< std::pair< float, float > >	cairoCoords
	contains all the internal cairo coordinates used to draw a wire More...

Static Private Attributes
static constexpr float	handleRadius =3

Friends
struct	SchemaHelper

Additional Inherited Members
Public Attributes inherited from minsky::NoteBase
bool	mouseFocus =false
	true if target of a mouseover More...
bool	selected =false
	true if selected for cut, copy or group operation More...
bool	bookmark =false
	Is this item also a bookmark? More...

Detailed Description

Definition at line 43 of file wire.h.

Constructor & Destructor Documentation

Wire() [1/2]

minsky::Wire::Wire ( )

inline

Definition at line 58 of file wire.h.

Referenced by split().

{}

Here is the caller graph for this function:

Wire() [2/2]

minsky::Wire::Wire	(	const std::weak_ptr< Port > &	from,
		const std::weak_ptr< Port > &	to,
		const std::vector< float > &	a_coords = std::vector<float>()
	)

Definition at line 90 of file wire.cc.

References coords(), from(), m_from, m_to, and to().

                                       : 
      m_from(from), m_to(to) 
  {
    if (!from.lock() || !to.lock()) throw error("wiring defunct ports");
    if (from.lock()->input() || !to.lock()->input()) throw error("invalid ports for wire");
    coords(a_coords);
    m_from.lock()->m_wires.push_back(this);
    m_to.lock()->m_wires.push_back(this);
  }

Here is the call graph for this function:

~Wire()

minsky::Wire::~Wire

(

)

Definition at line 101 of file wire.cc.

References from(), and to().

  {
    if (auto toPort=to())
      toPort->eraseWire(this);
    if (auto fromPort=from())
      fromPort->eraseWire(this);
  }

Here is the call graph for this function:

Member Function Documentation

CLASSDESC_ACCESS()

minsky::Wire::CLASSDESC_ACCESS ( Wire  )

private

coords() [1/2]

vector< float > minsky::Wire::coords

(

)

const

display coordinates

Definition at line 45 of file wire.cc.

References f, from(), m_coords, minsky::sqr(), MathDAG::sqrt(), and to().

Referenced by coords(), deleteHandle(), draw(), editHandle(), insertHandle(), near(), nearestHandle(), schema3::populateWire(), and Wire().

  {
    vector<float> c;
    assert(from() && to());
    assert(m_coords.size() % 2 == 0);
    if (auto f=from())
      if (auto t=to())
        {
          c.push_back(f->x());
          c.push_back(f->y());
          const float d=sqrt
            (sqr(f->x()-t->x())+sqr(f->y()-t->y()));

          for (size_t i=0; m_coords.size()>1 && i<m_coords.size()-1; i+=2)
            {
              c.push_back(f->x() + d*m_coords[i]);
              c.push_back(f->y() + d*m_coords[i+1]);
            }
          c.push_back(t->x());
          c.push_back(t->y());
        }
    return c;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

coords() [2/2]

vector< float > minsky::Wire::coords

(

const std::vector< float > &

coords

)

Definition at line 69 of file wire.cc.

References coords(), m_coords, minsky::sqr(), and MathDAG::sqrt().

  {
    if (coords.size()<6) 
      m_coords.clear();
    else
      {
        assert(coords.size() % 2 == 0);
        
        const float d=1/sqrt
          (sqr(coords[coords.size()-2]-coords[0])+sqr(coords[coords.size()-1]-coords[1]));
        m_coords.resize(coords.size()-4);
        for (size_t i=2; i<coords.size()-3; i+=2)
          {
            m_coords[i-2] = (coords[i]-coords[0])*d;
            m_coords[i-1] = (coords[i+1]-coords[1])*d;
          }
      }
    return this->coords();
  }

Here is the call graph for this function:

deleteHandle()

void minsky::Wire::deleteHandle	(	float	x,
		float	y
	)

Definition at line 655 of file wire.cc.

References coords(), and minsky::anonymous_namespace{wire.cc}::d2().

  {         
    auto c=coords();
    auto n=c.begin(); // nearest index
    float closestD=d2(c[0],c[1],x,y);
    for (auto i=c.begin()+2; i<c.end()-1; i+=2)
      {
        const float d=d2(*i,*(i+1),x,y);
        if (d<closestD)
          {
            closestD=d;
            n=i;
          }
      }   
    assert(n<c.end()-1);    
    c.erase(n, n+2);
    coords(c);
  } 

Here is the call graph for this function:

draw()

void minsky::Wire::draw	(	cairo_t *	cairo,
		bool	reverseArrow = false
	)		const

draw this item into a cairo context

Two control points are inserted between two adjacent handles (knots) of the curved wires on the canvas. The first and second derivatives of the cubic Bezier curves, representing curved segments of wires, and spanning adjacent knots, are matched at the common knots. The second derivatives are set to zero at the ends to absorb the extra degrees of freedom, thus leading to a matrix equation relating control points \(c_i\) to the knots \(k_i\):

\[ \left(\begin{array}{c} b_1 & a_1 & 0 \\ d_1 & b_2 & a_2 \\ 0 & d_2 & b_3 \end{array}\right) \left(\begin{array}{c} c_1 \\ c_2 \\ c_3 \end{array}\right) = \left(\begin{array}{c} k_1 \\ k_2 \\ k_3 \end{array}\right) \]

Definition at line 374 of file wire.cc.

References cairoCoords, minsky::anonymous_namespace{wire.cc}::computeControlPoints(), minsky::anonymous_namespace{wire.cc}::constructTargetVector(), minsky::anonymous_namespace{wire.cc}::constructTriDiag(), coords(), handleRadius, minsky::latexToPango(), M_PI, minsky::NoteBase::mouseFocus, storeCairoCoords(), minsky::anonymous_namespace{wire.cc}::toCoordPair(), minsky::NoteBase::tooltip(), and visible().

Referenced by minsky::PhillipsFlow::draw().

  {
    auto coords=this->coords();
    if (coords.size()<4 || !visible()) return;

    float angle, lastx, lasty;
    if (coords.size()==4)
      {
        cairo_move_to(cairo,coords[0],coords[1]);
        cairo_line_to(cairo, coords[2], coords[3]);
        if (reverseArrow)
          {
            angle=atan2(coords[3]-coords[1], coords[2]-coords[0])+M_PI;
            lastx=coords[0]; lasty=coords[1];
          }
        else
          {
            angle=atan2(coords[3]-coords[1], coords[2]-coords[0]) + (reverseArrow? M_PI:0);
            lastx=coords[2]; lasty=coords[3];
          }
      }
    else
      {
        cairo_move_to(cairo, coords[0], coords[1]);
        
        // For ticket 991/1092. Convert to coordinate pairs.
        vector<pair<float,float>> points = toCoordPair(coords);
       
        const int n = points.size()-1;         
        
        // Initial vector of knots in the matrix equation Ac = k
        const vector<pair<float,float>> target = constructTargetVector(n, points);
      
        vector<vector<float>> A(n,vector<float>(n));
        // Initial matrix A which relates control points c_i to knots k_i by matching first and second derivatives of cubic Bezier curves at common points (knots) between curves.
        A = constructTriDiag(n);
                                             
        // For ticket 991. Apply Thomas' algorithm to matrix equation Ac=k
        vector<pair<float,float>> controlPoints = computeControlPoints(A, points, target);

        // Decrease tolerance a bit, since it's going to be magnified
        cairo_set_tolerance (cairo, 0.01);
        
        for (int i = 0; i < n; i++) {      
          cairo_curve_to(cairo, controlPoints[i].first,controlPoints[i].second,controlPoints[n+i].first,controlPoints[n+i].second,points[i+1].first,points[i+1].second);
        }                   
        
        // Stash the internal cairo coordinates used to draw curved wires. for ticket 1079.
        if (coords.size()>4) storeCairoCoords(cairo);    
                                         
        cairo_stroke(cairo);     
        angle=atan2(coords[coords.size()-1]-coords[coords.size()-3], 
                    coords[coords.size()-2]-coords[coords.size()-4]);                         
        lastx=coords[coords.size()-2]; lasty=coords[coords.size()-1];
      } 
    cairo_stroke(cairo);

    // draw arrow
    {
      const CairoSave cs(cairo);
      auto lw=cairo_get_line_width(cairo);
      cairo_translate(cairo, lastx, lasty);
      cairo_rotate(cairo,angle);
      cairo_move_to(cairo,0,0);
      cairo_line_to(cairo,-5*lw,-3*lw); 
      cairo_line_to(cairo,-3*lw,0); 
      cairo_line_to(cairo,-5*lw,3*lw);
      cairo_close_path(cairo);
      cairo_fill(cairo);
    }

    // draw handles
    if (mouseFocus)
      {
          const cairo::CairoSave cs(cairo);
          cairo_set_source_rgb(cairo,0,0,1);
          if (cairoCoords.empty() || coords.size()==4)
            {
              const double midx=0.5*(coords[0]+coords[2]);
              const double midy=0.5*(coords[1]+coords[3]);
              cairo_arc(cairo,midx,midy,1.5*handleRadius, 0, 2*M_PI);
              cairo_fill(cairo);
            } 
          else 
            {
              const size_t numSmallHandles=0.5*(coords.size()-4)+1, numCairoCoords=cairoCoords.size()-1;
              for (size_t i=0; i<coords.size()-3; i+=2)
                {
                  const double midx=cairoCoords[(i+1)*numCairoCoords/(2*numSmallHandles)].first;
                  const double midy=cairoCoords[(i+1)*numCairoCoords/(2*numSmallHandles)].second;
                  cairo_arc(cairo,midx,midy,handleRadius, 0, 2*M_PI);
                  if (i>0) // draw existing interior gripping handle            
                    cairo_arc(cairo,coords[i],coords[i+1],1.5*handleRadius, 0, 2*M_PI); 
                  cairo_fill(cairo);
                } 
            }
      }
    if (mouseFocus && !tooltip().empty())
      {
        const cairo::CairoSave cs(cairo);
        const string toolTipText=latexToPango(tooltip());
        ecolab::Pango pango(cairo);
        pango.setMarkup(toolTipText);
        // place tooltip on centre dot if an odd number of control points, or halfway between otherwise
        auto dd=div(coords.size(),4);
        assert(dd.rem%2==0);
        if (dd.quot&1) dd.quot+=dd.rem-1; // adjust so the dd.quot points to an x coordinate
        double midx=coords[dd.quot], midy=coords[dd.quot+1];
        if (dd.rem==0)
          {
            midx=0.5*(coords[dd.quot]+coords[dd.quot+2]);
            midy=0.5*(coords[dd.quot+1]+coords[dd.quot+3]);
          }
        cairo_translate(cairo,midx,midy);
        cairo_rectangle(cairo,0,0,pango.width(),pango.height());
        cairo_set_source_rgb(cairo,1,1,1);
        cairo_fill_preserve(cairo);
        cairo_set_source_rgb(cairo,0,0,0);
        cairo_set_line_width(cairo,1);
        cairo_set_dash(cairo,nullptr,0,0);
        pango.show();
        cairo_stroke(cairo);
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

editHandle()

void minsky::Wire::editHandle	(	unsigned	position,
		float	x,
		float	y
	)

Definition at line 674 of file wire.cc.

References coords().

Referenced by minsky::PhillipsDiagram::mouseMove().

  {
    position++;
    position*=2;
    auto c=coords();
    assert(position<c.size()-2);
    c[position]=x;
    c[position+1]=y;
    coords(c);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

from()

std::shared_ptr<Port> minsky::Wire::from ( ) const

inline

Definition at line 63 of file wire.h.

References m_from.

Referenced by coords(), moveToPorts(), split(), units(), visible(), Wire(), and ~Wire().

{return m_from.lock();}

Here is the caller graph for this function:

insertHandle()

void minsky::Wire::insertHandle	(	unsigned	position,
		float	x,
		float	y
	)

Definition at line 643 of file wire.cc.

References coords().

Referenced by nearestHandle().

  {
    n++;
    n*=2;
    auto c=coords();
    assert(n<c.size()-1);
    vector<float> h{x,y};
    c.insert(c.begin()+n,h.begin(), h.end());
    coords(c);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

moveIntoGroup()

void minsky::Wire::moveIntoGroup

(

Group &

dest

)

move this from its group into dest

Definition at line 131 of file wire.cc.

References minsky::GroupItems::addWire(), minsky::Group::globalGroup(), minsky::GroupItems::recursiveDo(), and minsky::GroupItems::wires.

  {
    WirePtr wp;
    // one hit find and remove wire from its map, saving the wire
    dest.globalGroup().recursiveDo
      (&Group::wires, 
       [&](Wires& wires, Wires::iterator i) {
        if (i->get()==this) 
          {
            wp=*i;
            wires.erase(i);
            return true;
          }
        return false;
      }); 
    if (wp)
      dest.addWire(wp);
  }

Here is the call graph for this function:

moveToPorts()

void minsky::Wire::moveToPorts	(	const std::shared_ptr< Port > &	from,
		const std::shared_ptr< Port > &	to
	)

switch ports this wire links to

Definition at line 118 of file wire.cc.

References f, from(), m_from, m_to, and to().

Referenced by split().

  {
    if (auto f=this->from())
      f->m_wires.erase(remove(f->m_wires.begin(), f->m_wires.end(), this), f->m_wires.end());
    if (auto t=this->to())
      t->m_wires.erase(remove(t->m_wires.begin(), t->m_wires.end(), this), t->m_wires.end());
    m_from=from;
    m_to=to;
    from->m_wires.push_back(this);
    to->m_wires.push_back(this);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

near()

bool minsky::Wire::near	(	float	x,
		float	y
	)		const

returns true if coordinates are near this wire

Definition at line 574 of file wire.cc.

References minsky::anonymous_namespace{wire.cc}::allHandleCoords(), cairoCoords, coords(), minsky::anonymous_namespace{wire.cc}::d2(), and minsky::anonymous_namespace{wire.cc}::segNear().

  {
    auto c=coords();
    assert(c.size()>=4);
    if (c.size()==4)
      return segNear(c[0],c[1],c[2],c[3],x,y);

    // fixes for tickets 991/1095
    vector<pair<float,float>> p=allHandleCoords(c);
    if (!cairoCoords.empty()) p=cairoCoords;   
         
    unsigned k=0; // nearest index
    float closestD=d2(p[0].first,p[0].second,x,y);      
    for (size_t i=0; i<p.size(); i++)
      {
        const float d=d2(p[i].first,p[i].second,x,y);
        if (d<=closestD)
          {
            closestD=d;
            k=i;
          }
      }
      
    // Check for proximity to line segments about index k
    if (k>0 && k<p.size()-1)  
      return (segNear(p[k-1].first,p[k-1].second,p[k].first,p[k].second,x,y) || segNear(p[k].first,p[k].second,p[k+1].first,p[k+1].second,x,y));      
    return false;
  }

Here is the call graph for this function:

nearestHandle()

unsigned minsky::Wire::nearestHandle	(	float	x,
		float	y
	)

returns the index into the coordinate list if x,y is close to it. Otherwise inserts midpoints and returns that. Wire endpoints are not returned

Definition at line 603 of file wire.cc.

References coords(), minsky::anonymous_namespace{wire.cc}::d2(), and insertHandle().

  {
    auto c=coords();
           
    unsigned n=0; // nearest index
    float closestD=d2(c[0],c[1],x,y);
    for (size_t i=2; i<c.size()-1; i+=2)
      {
        const float d=d2(c[i],c[i+1],x,y);        
        if (d<=closestD)
          {
            closestD=d;
            n=i;                            
          } 
      }
      
    // now work out if we need to insert a midpoint handle
    if (n>0)
      {
        const float mx=0.5*(c[n]+c[n-2]), my=0.5*(c[n+1]+c[n-1]);
        const float d=d2(mx,my,x,y);
        if (n==c.size()-2 || d<closestD)
          {
            insertHandle((n>>1)-1, mx, my);
            return (n>>1)-1;
          }
      }
    if (n<c.size()-3)
      {
        const float mx=0.5*(c[n+2]+c[n]), my=0.5*(c[n+3]+c[n+1]);
        const float d=d2(mx,my,x,y);
        if (n==0 || d<closestD)
          {
            insertHandle(n>>1, mx, my);
            return (n>>1);
          }
      }
    return (n>>1)-1;
  }

Here is the call graph for this function:

split()

void minsky::Wire::split

(

)

splits wires crossing group boundaries

Definition at line 513 of file wire.cc.

References from(), moveToPorts(), to(), and Wire().

  {
    // add I/O variables if this wire crosses a group boundary
    if (auto fg=from()->item().group.lock())
      if (auto tg=to()->item().group.lock())
        if (fg!=tg && !from()->item().ioVar() && !to()->item().ioVar()) // crosses boundary
          {
            // check if this wire is in from group
            auto cmp=[&](const WirePtr& w) {return w.get()==this;};
            auto i=find_if(fg->wires.begin(), fg->wires.end(), cmp);
            if (i==fg->wires.end())
              {
                fg->addOutputVar();
                assert(fg->outVariables.back()->portsSize()>1);
                fg->addWire(new Wire(from(),fg->outVariables.back()->ports(1)));
                moveToPorts(fg->outVariables.back()->ports(0).lock(), to());
              }
            // check if this wire is in to group
            i=find_if(tg->wires.begin(), tg->wires.end(), cmp);
            if (i==tg->wires.end())
              {
                tg->addInputVar();
                assert(tg->inVariables.back()->portsSize()>1);
                tg->addWire(new Wire(tg->inVariables.back()->ports(0),to()));
                moveToPorts(from(), tg->inVariables.back()->ports(1).lock());
              }
          }
  }

Here is the call graph for this function:

storeCairoCoords()

void minsky::Wire::storeCairoCoords

(

cairo_t *

cairo

)

const

stash all the internal cairo coordinates along a wire

Definition at line 350 of file wire.cc.

References cairoCoords.

Referenced by draw().

  {
    cairoCoords.clear(); 
    cairo_path_t *path;
    cairo_path_data_t *data;
         
    path = cairo_copy_path_flat(cairo);
         
    for (int j=0; j < path->num_data; j += path->data[j].header.length) {
      data = &path->data[j];
      switch (data->header.type) {
      case CAIRO_PATH_MOVE_TO:
        break;
      case CAIRO_PATH_LINE_TO:
        cairoCoords.push_back(make_pair(data[1].point.x,data[1].point.y));
        break;
      case CAIRO_PATH_CURVE_TO:
      case CAIRO_PATH_CLOSE_PATH:
        break;
      }
    }
    cairo_path_destroy (path);              
  }

Here is the caller graph for this function:

straighten()

void minsky::Wire::straighten ( )

inline

Definition at line 90 of file wire.h.

References m_coords.

{m_coords.clear();}

to()

std::shared_ptr<Port> minsky::Wire::to ( ) const

inline

Definition at line 64 of file wire.h.

References m_to.

Referenced by coords(), moveToPorts(), split(), visible(), Wire(), and ~Wire().

{return m_to.lock();}

Here is the caller graph for this function:

units()

Units minsky::Wire::units

(

bool

check

)

const

units (dimensional analysis) of data flowing across wire

Definition at line 542 of file wire.cc.

References f, from(), and unitsCtr.

  {
      
    if (auto f=from())
      {
        // we allow possible traversing twice over a wire, to allow an
        // integral to break the cycle
        if (unitsCtr>2)
          f->item().throw_error("wiring loop detected");
        const IncrDecrCounter idc(unitsCtr);
        return f->item().units(check);
      }
    return {};
  }

Here is the call graph for this function:

visible()

bool minsky::Wire::visible

(

)

const

whether this wire is visible or not

Definition at line 109 of file wire.cc.

References f, from(), and to().

Referenced by draw().

  {
    auto f=from(), t=to();
    auto fgroup=f->item().group.lock(), tgroup=t->item().group.lock();
    return f && t && 
      (!fgroup || fgroup->displayContents() ||
       !tgroup || tgroup->displayContents());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

SchemaHelper

friend struct SchemaHelper

friend

Definition at line 46 of file wire.h.

Member Data Documentation

cairoCoords

std::vector<std::pair<float,float> > minsky::Wire::cairoCoords

mutableprivate

contains all the internal cairo coordinates used to draw a wire

Definition at line 55 of file wire.h.

Referenced by draw(), near(), and storeCairoCoords().

handleRadius

constexpr float minsky::Wire::handleRadius =3

staticprivate

Definition at line 53 of file wire.h.

Referenced by draw().

m_coords

std::vector<float> minsky::Wire::m_coords

private

Definition at line 49 of file wire.h.

Referenced by coords(), and straighten().

m_from

std::weak_ptr<Port> minsky::Wire::m_from

private

ports this wire connects

Definition at line 51 of file wire.h.

Referenced by from(), moveToPorts(), and Wire().

m_to

std::weak_ptr<Port> minsky::Wire::m_to

private

Definition at line 51 of file wire.h.

Referenced by moveToPorts(), to(), and Wire().

unitsCtr

int minsky::Wire::unitsCtr =0

mutableprivate

for detecting wiring loops in units()

Definition at line 54 of file wire.h.

Referenced by units().

---

The documentation for this class was generated from the following files:

• model/wire.h
• model/wire.cc