// create agc object
AGC() AGC(_create)(void)
{
// create object and initialize to default parameters
AGC() _q = (AGC()) malloc(sizeof(struct AGC(_s)));
// initialize bandwidth
AGC(_set_bandwidth)(_q, AGC_DEFAULT_BW);
// reset object
AGC(_reset)(_q);
// return object
return _q;
}
// create symtrack object with basic parameters
// _ftype : filter type (e.g. LIQUID_FIRFILT_RRC)
// _k : samples per symbol
// _m : filter delay (symbols)
// _beta : filter excess bandwidth
// _ms : modulation scheme (e.g. LIQUID_MODEM_QPSK)
SYMTRACK() SYMTRACK(_create)(int _ftype,
unsigned int _k,
unsigned int _m,
float _beta,
int _ms)
{
// validate input
if (_k < 2) {
fprintf(stderr,"error: symtrack_%s_create(), filter samples/symbol must be at least 2\n", EXTENSION_FULL);
exit(1);
} else if (_m == 0) {
fprintf(stderr,"error: symtrack_%s_create(), filter delay must be greater than zero\n", EXTENSION_FULL);
exit(1);
} else if (_beta <= 0.0f || _beta > 1.0f) {
fprintf(stderr,"error: symtrack_%s_create(), filter excess bandwidth must be in (0,1]\n", EXTENSION_FULL);
exit(1);
} else if (_ms == LIQUID_MODEM_UNKNOWN || _ms >= LIQUID_MODEM_NUM_SCHEMES) {
fprintf(stderr,"error: symtrack_%s_create(), invalid modulation scheme\n", EXTENSION_FULL);
exit(1);
}
// allocate memory for main object
SYMTRACK() q = (SYMTRACK()) malloc( sizeof(struct SYMTRACK(_s)) );
// set input parameters
q->filter_type = _ftype;
q->k = _k;
q->m = _m;
q->beta = _beta;
q->mod_scheme = _ms == LIQUID_MODEM_UNKNOWN ? LIQUID_MODEM_BPSK : _ms;
// create automatic gain control
q->agc = AGC(_create)();
// create symbol synchronizer (output rate: 2 samples per symbol)
if (q->filter_type == LIQUID_FIRFILT_UNKNOWN)
q->symsync = SYMSYNC(_create_kaiser)(q->k, q->m, 0.9f, 16);
else
q->symsync = SYMSYNC(_create_rnyquist)(q->filter_type, q->k, q->m, q->beta, 16);
SYMSYNC(_set_output_rate)(q->symsync, 2);
// create equalizer as default low-pass filter with integer symbol delay (2 samples/symbol)
q->eq_len = 2 * 4 + 1;
q->eq = EQLMS(_create_lowpass)(q->eq_len,0.45f);
// nco and phase-locked loop
q->nco = NCO(_create)(LIQUID_VCO);
// demodulator
q->demod = MODEM(_create)(q->mod_scheme);
// set default bandwidth
SYMTRACK(_set_bandwidth)(q, 0.9f);
// reset and return main object
SYMTRACK(_reset)(q);
return q;
}
static void update(pjmedia_delay_buf *b, enum OP op)
{
/* Sequential operation */
if (op == b->last_op) {
++b->level;
return;
}
/* Switching operation */
if (b->level > b->max_level)
b->max_level = b->level;
b->recalc_timer -= (b->level * b->ptime) >> 1;
b->last_op = op;
b->level = 1;
/* Recalculate effective count based on max_level */
if (b->recalc_timer <= 0) {
unsigned new_eff_cnt = (b->max_level+SAFE_MARGIN)*b->samples_per_frame;
/* Smoothening effective count transition */
AGC(b->eff_cnt, new_eff_cnt);
/* Make sure the new effective count is multiplication of
* channel_count, so let's round it up.
*/
if (b->eff_cnt % b->channel_count)
b->eff_cnt += b->channel_count - (b->eff_cnt % b->channel_count);
TRACE__((b->obj_name,"Cur eff_cnt=%d", b->eff_cnt));
b->max_level = 0;
b->recalc_timer = RECALC_TIME;
}
/* See if we need to shrink the buffer to reduce delay */
if (op == OP_PUT && pjmedia_circ_buf_get_len(b->circ_buf) >
b->samples_per_frame + b->eff_cnt)
{
unsigned erase_cnt = b->samples_per_frame >> 1;
unsigned old_buf_cnt = pjmedia_circ_buf_get_len(b->circ_buf);
shrink_buffer(b, erase_cnt);
PJ_LOG(4,(b->obj_name,"Buffer size adjusted from %d to %d (eff_cnt=%d)",
old_buf_cnt,
pjmedia_circ_buf_get_len(b->circ_buf),
b->eff_cnt));
}
// does the actual computation. fixedNodes and fixedPositions
// contain the nodes with fixed positions.
bool TutteLayout::doCall(
GraphAttributes &AG,
const List<node> &fixedNodes,
List<DPoint> &fixedPositions)
{
//node v, w;
//edge e;
const Graph &G = AG.constGraph();
GraphCopy GC(G);
GraphCopyAttributes AGC(GC, AG);
// mark fixed nodes and set their positions in a
NodeArray<bool> fixed(GC, false);
for (node v : fixedNodes) {
fixed[v] = true;
DPoint p = fixedPositions.popFrontRet(); // slightly dirty...
fixedPositions.pushBack(p); // ...
AGC.x(v) = p.m_x;
AGC.y(v) = p.m_y;
}
if (fixedNodes.size() == G.numberOfNodes()) {
for (node v : GC.nodes) {
AG.x(GC.original(v)) = AGC.x(v);
AG.y(GC.original(v)) = AGC.y(v);
}
return true;
}
// all nodes have fixed positions - nothing left to do
// collect other nodes
List<node> otherNodes;
for (node v : GC.nodes)
if (!fixed[v]) otherNodes.pushBack(v);
NodeArray<int> ind(GC); // position of v in otherNodes and A
int i = 0;
for (node v : otherNodes)
ind[v] = i++;
int n = otherNodes.size(); // #other nodes
Array<double> coord(n); // coordinates (first x then y)
Array<double> rhs(n); // right hand side
double oneOverD = 0.0;
CoinPackedMatrix A(false, 0, 0); // equations
A.setDimensions(n, n);
// initialize non-zero entries in matrix A
for (node v : otherNodes) {
oneOverD = (double) (1.0 / (v->degree()));
edge e;
forall_adj_edges(e, v) {
// get second node of e
node w = e->opposite(v);
if (!fixed[w]) {
A.modifyCoefficient(ind[v], ind[w], oneOverD);
}
}
A.modifyCoefficient(ind[v], ind[v], -1);
}
void SpringEmbedderFR::call(GraphAttributes &AG)
{
const Graph &G = AG.constGraph();
if(G.empty())
return;
// all edges straight-line
AG.clearAllBends();
GraphCopy GC;
GC.createEmpty(G);
// compute connected component of G
NodeArray<int> component(G);
int numCC = connectedComponents(G,component);
// intialize the array of lists of nodes contained in a CC
Array<List<node> > nodesInCC(numCC);
node v;
forall_nodes(v,G)
nodesInCC[component[v]].pushBack(v);
EdgeArray<edge> auxCopy(G);
Array<DPoint> boundingBox(numCC);
int i;
for(i = 0; i < numCC; ++i)
{
GC.initByNodes(nodesInCC[i],auxCopy);
GraphCopyAttributes AGC(GC,AG);
node vCopy;
forall_nodes(vCopy, GC) {
node vOrig = GC.original(vCopy);
AGC.x(vCopy) = AG.x(vOrig);
AGC.y(vCopy) = AG.y(vOrig);
}
// original
if (initialize(GC, AGC) == true)
{
for(int i = 1; i <= m_iterations; i++)
mainStep(GC, AGC);
}
cleanup();
// end original
node vFirst = GC.firstNode();
double minX = AGC.x(vFirst), maxX = AGC.x(vFirst),
minY = AGC.y(vFirst), maxY = AGC.y(vFirst);
forall_nodes(vCopy,GC) {
node v = GC.original(vCopy);
AG.x(v) = AGC.x(vCopy);
AG.y(v) = AGC.y(vCopy);
if(AG.x(v)-AG.width (v)/2 < minX) minX = AG.x(v)-AG.width(v) /2;
if(AG.x(v)+AG.width (v)/2 > maxX) maxX = AG.x(v)+AG.width(v) /2;
if(AG.y(v)-AG.height(v)/2 < minY) minY = AG.y(v)-AG.height(v)/2;
if(AG.y(v)+AG.height(v)/2 > maxY) maxY = AG.y(v)+AG.height(v)/2;
}
{
// create object and initialize to default parameters
AGC() _q = (AGC()) malloc(sizeof(struct AGC(_s)));
// initialize bandwidth
AGC(_set_bandwidth)(_q, AGC_DEFAULT_BW);
// reset object
AGC(_reset)(_q);
// return object
return _q;
}
// destroy agc object, freeing all internally-allocated memory
void AGC(_destroy)(AGC() _q)
{
// free main object memory
free(_q);
}
// print agc object internals
void AGC(_print)(AGC() _q)
{
printf("agc [rssi: %12.4fdB]:\n", AGC(_get_rssi)(_q));
}
// reset agc object's internal state
void AGC(_reset)(AGC() _q)
{
// reset gain estimate
void GEMLayout::call(GraphAttributes &AG)
{
const Graph &G = AG.constGraph();
if(G.empty())
return;
OGDF_ASSERT(m_numberOfRounds >= 0);
OGDF_ASSERT(DIsGreaterEqual(m_minimalTemperature,0));
OGDF_ASSERT(DIsGreaterEqual(m_initialTemperature,m_minimalTemperature));
OGDF_ASSERT(DIsGreaterEqual(m_gravitationalConstant,0));
OGDF_ASSERT(DIsGreaterEqual(m_desiredLength,0));
OGDF_ASSERT(DIsGreaterEqual(m_maximalDisturbance,0));
OGDF_ASSERT(DIsGreaterEqual(m_rotationAngle,0));
OGDF_ASSERT(DIsLessEqual(m_rotationAngle,pi / 2));
OGDF_ASSERT(DIsGreaterEqual(m_oscillationAngle,0));
OGDF_ASSERT(DIsLessEqual(m_oscillationAngle,pi / 2));
OGDF_ASSERT(DIsGreaterEqual(m_rotationSensitivity,0));
OGDF_ASSERT(DIsLessEqual(m_rotationSensitivity,1));
OGDF_ASSERT(DIsGreaterEqual(m_oscillationSensitivity,0));
OGDF_ASSERT(DIsLessEqual(m_oscillationSensitivity,1));
OGDF_ASSERT(m_attractionFormula == 1 || m_attractionFormula == 2);
// all edges straight-line
AG.clearAllBends();
GraphCopy GC;
GC.createEmpty(G);
// compute connected component of G
NodeArray<int> component(G);
int numCC = connectedComponents(G,component);
// intialize the array of lists of nodes contained in a CC
Array<List<node> > nodesInCC(numCC);
node v;
forall_nodes(v,G)
nodesInCC[component[v]].pushBack(v);
EdgeArray<edge> auxCopy(G);
Array<DPoint> boundingBox(numCC);
int i;
for(i = 0; i < numCC; ++i)
{
GC.initByNodes(nodesInCC[i],auxCopy);
GraphCopyAttributes AGC(GC,AG);
node vCopy;
forall_nodes(vCopy, GC) {
node vOrig = GC.original(vCopy);
AGC.x(vCopy) = AG.x(vOrig);
AGC.y(vCopy) = AG.y(vOrig);
}
SList<node> permutation;
node v;
// initialize node data
m_impulseX.init(GC,0);
m_impulseY.init(GC,0);
m_skewGauge.init(GC,0);
m_localTemperature.init(GC,m_initialTemperature);
// initialize other data
m_globalTemperature = m_initialTemperature;
m_barycenterX = 0;
m_barycenterY = 0;
forall_nodes(v,GC) {
m_barycenterX += weight(v) * AGC.x(v);
m_barycenterY += weight(v) * AGC.y(v);
}
void GEMLayout::call(GraphAttributes &AG)
{
const Graph &G = AG.constGraph();
if(G.empty())
return;
// all edges straight-line
AG.clearAllBends();
GraphCopy GC;
GC.createEmpty(G);
// compute connected component of G
NodeArray<int> component(G);
int numCC = connectedComponents(G,component);
// intialize the array of lists of nodes contained in a CC
Array<List<node> > nodesInCC(numCC);
for(node v : G.nodes)
nodesInCC[component[v]].pushBack(v);
EdgeArray<edge> auxCopy(G);
Array<DPoint> boundingBox(numCC);
int i;
for(i = 0; i < numCC; ++i)
{
GC.initByNodes(nodesInCC[i],auxCopy);
GraphCopyAttributes AGC(GC,AG);
for(node vCopy : GC.nodes) {
node vOrig = GC.original(vCopy);
AGC.x(vCopy) = AG.x(vOrig);
AGC.y(vCopy) = AG.y(vOrig);
}
SList<node> permutation;
// initialize node data
m_impulseX.init(GC,0);
m_impulseY.init(GC,0);
m_skewGauge.init(GC,0);
m_localTemperature.init(GC,m_initialTemperature);
// initialize other data
m_globalTemperature = m_initialTemperature;
m_barycenterX = 0;
m_barycenterY = 0;
for(node v : GC.nodes) {
m_barycenterX += weight(v) * AGC.x(v);
m_barycenterY += weight(v) * AGC.y(v);
}
m_cos = cos(m_oscillationAngle / 2.0);
m_sin = sin(Math::pi / 2 + m_rotationAngle / 2.0);
// main loop
int counter = m_numberOfRounds;
while(OGDF_GEOM_ET.greater(m_globalTemperature,m_minimalTemperature) && counter--) {
// choose nodes by random permutations
if(permutation.empty()) {
for(node v : GC.nodes)
permutation.pushBack(v);
permutation.permute(m_rng);
}
node v = permutation.popFrontRet();
// compute the impulse of node v
computeImpulse(GC,AGC,v);
// update node v
updateNode(GC,AGC,v);
}
node vFirst = GC.firstNode();
double minX = AGC.x(vFirst), maxX = AGC.x(vFirst),
minY = AGC.y(vFirst), maxY = AGC.y(vFirst);
for(node vCopy : GC.nodes) {
node v = GC.original(vCopy);
AG.x(v) = AGC.x(vCopy);
AG.y(v) = AGC.y(vCopy);
if(AG.x(v)-AG.width (v)/2 < minX) minX = AG.x(v)-AG.width(v) /2;
if(AG.x(v)+AG.width (v)/2 > maxX) maxX = AG.x(v)+AG.width(v) /2;
if(AG.y(v)-AG.height(v)/2 < minY) minY = AG.y(v)-AG.height(v)/2;
if(AG.y(v)+AG.height(v)/2 > maxY) maxY = AG.y(v)+AG.height(v)/2;
}
minX -= m_minDistCC;
minY -= m_minDistCC;
for(node vCopy : GC.nodes) {
node v = GC.original(vCopy);
AG.x(v) -= minX;
AG.y(v) -= minY;
}
boundingBox[i] = DPoint(maxX - minX, maxY - minY);
}
Array<DPoint> offset(numCC);
TileToRowsCCPacker packer;
packer.call(boundingBox,offset,m_pageRatio);
// The arrangement is given by offset to the origin of the coordinate
// system. We still have to shift each node and edge by the offset
// of its connected component.
for(i = 0; i < numCC; ++i)
{
const List<node> &nodes = nodesInCC[i];
const double dx = offset[i].m_x;
const double dy = offset[i].m_y;
// iterate over all nodes in ith CC
ListConstIterator<node> it;
for(node v : nodes)
{
AG.x(v) += dx;
AG.y(v) += dy;
}
}
// free node data
m_impulseX.init();
m_impulseY.init();
m_skewGauge.init();
m_localTemperature.init();
}
