_Use_decl_annotations_
HRESULT CDataBlock::AddData(const void *pvNewData, uint32_t bufferSize, CDataBlock **ppBlock)
{
HRESULT hr = S_OK;
uint32_t bytesToCopy;
const uint8_t *pNewData = (const uint8_t*) pvNewData;
if (m_maxSize == 0)
{
// This is a brand new DataBlock, fill it up
m_maxSize = std::max<uint32_t>(8192, bufferSize);
VN( m_pData = new uint8_t[m_maxSize] );
}
assert(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
bytesToCopy = std::min(m_maxSize - m_size, bufferSize);
memcpy(m_pData + m_size, pNewData, bytesToCopy);
pNewData += bytesToCopy;
if (m_IsAligned)
{
assert(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
m_size += AlignToPowerOf2(bytesToCopy, c_DataAlignment);
}
else
{
m_size += bytesToCopy;
}
bufferSize -= bytesToCopy;
*ppBlock = this;
if (bufferSize != 0)
{
assert(nullptr == m_pNext); // make sure we're not overwriting anything
// Couldn't fit all data into this block, spill over into next
VN( m_pNext = new CDataBlock() );
if (m_IsAligned)
{
m_pNext->EnableAlignment();
}
VH( m_pNext->AddData(pNewData, bufferSize, ppBlock) );
}
lExit:
return hr;
}
HRESULT CDataBlock::AddData(const void *pvNewData, UINT bufferSize, CDataBlock **ppBlock)
{
HRESULT hr = S_OK;
UINT bytesToCopy;
const BYTE *pNewData = (const BYTE*) pvNewData;
if (m_maxSize == 0)
{
// This is a brand new DataBlock, fill it up
m_maxSize = max(8192, bufferSize);
VN( m_pData = NEW BYTE[m_maxSize] );
}
D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
bytesToCopy = min(m_maxSize - m_size, bufferSize);
memcpy(m_pData + m_size, pNewData, bytesToCopy);
pNewData += bytesToCopy;
if (m_IsAligned)
{
D3DXASSERT(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
m_size += AlignToPowerOf2(bytesToCopy, c_DataAlignment);
}
else
{
m_size += bytesToCopy;
}
bufferSize -= bytesToCopy;
*ppBlock = this;
if (bufferSize != 0)
{
D3DXASSERT(NULL == m_pNext); // make sure we're not overwriting anything
// Couldn't fit all data into this block, spill over into next
VN( m_pNext = NEW CDataBlock() );
if (m_IsAligned)
{
m_pNext->EnableAlignment();
}
VH( m_pNext->AddData(pNewData, bufferSize, ppBlock) );
}
lExit:
return hr;
}
void print_ntp_control_message(const ntp_control_message *p){
int i=0, numpeers=0;
const ntp_assoc_status_pair *peer=NULL;
printf("control packet contents:\n");
printf("\tflags: 0x%.2x , 0x%.2x\n", p->flags, p->op);
printf("\t li=%d (0x%.2x)\n", LI(p->flags), p->flags&LI_MASK);
printf("\t vn=%d (0x%.2x)\n", VN(p->flags), p->flags&VN_MASK);
printf("\t mode=%d (0x%.2x)\n", MODE(p->flags), p->flags&MODE_MASK);
printf("\t response=%d (0x%.2x)\n", (p->op&REM_RESP)>0, p->op&REM_RESP);
printf("\t more=%d (0x%.2x)\n", (p->op&REM_MORE)>0, p->op&REM_MORE);
printf("\t error=%d (0x%.2x)\n", (p->op&REM_ERROR)>0, p->op&REM_ERROR);
printf("\t op=%d (0x%.2x)\n", p->op&OP_MASK, p->op&OP_MASK);
printf("\tsequence: %d (0x%.2x)\n", ntohs(p->seq), ntohs(p->seq));
printf("\tstatus: %d (0x%.2x)\n", ntohs(p->status), ntohs(p->status));
printf("\tassoc: %d (0x%.2x)\n", ntohs(p->assoc), ntohs(p->assoc));
printf("\toffset: %d (0x%.2x)\n", ntohs(p->offset), ntohs(p->offset));
printf("\tcount: %d (0x%.2x)\n", ntohs(p->count), ntohs(p->count));
numpeers=ntohs(p->count)/(sizeof(ntp_assoc_status_pair));
if(p->op&REM_RESP && p->op&OP_READSTAT){
peer=(ntp_assoc_status_pair*)p->data;
for(i=0;i<numpeers;i++){
printf("\tpeer id %.2x status %.2x",
ntohs(peer[i].assoc), ntohs(peer[i].status));
if (PEER_SEL(peer[i].status) >= PEER_INCLUDED){
if(PEER_SEL(peer[i].status) >= PEER_SYNCSOURCE){
printf(" <-- current sync source");
} else {
printf(" <-- current sync candidate");
}
}
printf("\n");
}
}
}
HRESULT CDataBlockStore::AddData(const void *pNewData, UINT bufferSize, UINT *pCurOffset)
{
HRESULT hr = S_OK;
if (bufferSize == 0)
{
if (pCurOffset)
{
*pCurOffset = 0;
}
goto lExit;
}
if (!m_pFirst)
{
VN( m_pFirst = NEW CDataBlock() );
if (m_IsAligned)
{
m_pFirst->EnableAlignment();
}
m_pLast = m_pFirst;
}
if (pCurOffset)
*pCurOffset = m_Size + m_Offset;
VH( m_pLast->AddData(pNewData, bufferSize, &m_pLast) );
m_Size += bufferSize;
lExit:
return hr;
}
ClusteringInfo GraphKMeans::groupPoints(const vector<DotNode*>& means, ConnectedDotGraph& g)
{
VVN groups = VVN(means.size(), VN());
vector<DotNode*> median;
for (int i = 0; i < (int)means.size(); i++)
median.push_back(means[i]);
for (int it = 0; it < 10; it++)
{
groups = VVN(median.size(), VN());
for (int i = 0; i < (int)g.nodes.size(); i++)
{
double minDis = 123456789.0;
int bestIndex = -1;
for (int j = 0; j < (int)means.size(); j++)
{
double d = g.getShortestPath(g.nodes[i], means[j], true);
if (minDis > d)
{
minDis = d;
bestIndex = j;
}
}
assert(bestIndex != -1);
assert(minDis < 1234567.0);
groups[bestIndex].push_back(g.nodes[i]);
}
bool progress = false;
for (int i = 0; i < (int)median.size(); i++)
{
DotNode* newMedian = computeMedian(groups[i], g);
if (median[i] != newMedian) progress = true;
median[i] = newMedian;
}
if (!progress) break;
}
return ClusteringInfo(&g, groups);
}
/* print out a ntp packet in human readable/debuggable format */
void print_ntp_message(const ntp_message *p){
struct timeval ref, orig, rx, tx;
NTP64toTV(p->refts,ref);
NTP64toTV(p->origts,orig);
NTP64toTV(p->rxts,rx);
NTP64toTV(p->txts,tx);
printf("packet contents:\n");
printf("\tflags: 0x%.2x\n", p->flags);
printf("\t li=%d (0x%.2x)\n", LI(p->flags), p->flags&LI_MASK);
printf("\t vn=%d (0x%.2x)\n", VN(p->flags), p->flags&VN_MASK);
printf("\t mode=%d (0x%.2x)\n", MODE(p->flags), p->flags&MODE_MASK);
printf("\tstratum = %d\n", p->stratum);
printf("\tpoll = %g\n", pow(2, p->poll));
printf("\tprecision = %g\n", pow(2, p->precision));
printf("\trtdelay = %-.16g\n", NTP32asDOUBLE(p->rtdelay));
printf("\trtdisp = %-.16g\n", NTP32asDOUBLE(p->rtdisp));
printf("\trefid = %x\n", p->refid);
printf("\trefts = %-.16g\n", NTP64asDOUBLE(p->refts));
printf("\torigts = %-.16g\n", NTP64asDOUBLE(p->origts));
printf("\trxts = %-.16g\n", NTP64asDOUBLE(p->rxts));
printf("\ttxts = %-.16g\n", NTP64asDOUBLE(p->txts));
}
#endif
#include "fd_main.h"
#include "fd_spec.h"
#include "sp_dial.h"
#include "private/pdial.h"
#include "spec/dial_spec.h"
static FD_dialattrib * dial_attrib;
static FL_OBJECT * curobj;
#define VN( a ) { a, #a }
static FLI_VN_PAIR dial_dir[ ] =
{
VN( FL_DIAL_CW ),
VN( FL_DIAL_CCW ),
{ -1, NULL }
};
/***************************************
***************************************/
int
get_direction_value( const char * s )
{
return fli_get_vn_value( dial_dir, s );
}
std::vector<std::shared_ptr<Shape>> CreateNURBS(const Transform *o2w,
const Transform *w2o,
bool reverseOrientation,
const ParamSet ¶ms) {
int nu = params.FindOneInt("nu", -1);
if (nu == -1) {
Error("Must provide number of control points \"nu\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
int uorder = params.FindOneInt("uorder", -1);
if (uorder == -1) {
Error("Must provide u order \"uorder\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
int nuknots, nvknots;
const Float *uknots = params.FindFloat("uknots", &nuknots);
if (uknots == nullptr) {
Error("Must provide u knot vector \"uknots\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
if (nuknots != nu + uorder) {
Error(
"Number of knots in u knot vector %d doesn't match sum of "
"number of u control points %d and u order %d.",
nuknots, nu, uorder);
return std::vector<std::shared_ptr<Shape>>();
}
Float u0 = params.FindOneFloat("u0", uknots[uorder - 1]);
Float u1 = params.FindOneFloat("u1", uknots[nu]);
int nv = params.FindOneInt("nv", -1);
if (nv == -1) {
Error("Must provide number of control points \"nv\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
int vorder = params.FindOneInt("vorder", -1);
if (vorder == -1) {
Error("Must provide v order \"vorder\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
const Float *vknots = params.FindFloat("vknots", &nvknots);
if (vknots == nullptr) {
Error("Must provide v knot vector \"vknots\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
if (nvknots != nv + vorder) {
Error(
"Number of knots in v knot vector %d doesn't match sum of "
"number of v control points %d and v order %d.",
nvknots, nv, vorder);
return std::vector<std::shared_ptr<Shape>>();
}
Float v0 = params.FindOneFloat("v0", vknots[vorder - 1]);
Float v1 = params.FindOneFloat("v1", vknots[nv]);
bool isHomogeneous = false;
int npts;
const Float *P = (const Float *)params.FindPoint3f("P", &npts);
if (!P) {
P = params.FindFloat("Pw", &npts);
if (!P) {
Error(
"Must provide control points via \"P\" or \"Pw\" parameter to "
"NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
if ((npts % 4) != 0) {
Error(
"Number of \"Pw\" control points provided to NURBS shape must "
"be "
"multiple of four");
return std::vector<std::shared_ptr<Shape>>();
}
npts /= 4;
isHomogeneous = true;
}
if (npts != nu * nv) {
Error("NURBS shape was expecting %dx%d=%d control points, was given %d",
nu, nv, nu * nv, npts);
return std::vector<std::shared_ptr<Shape>>();
}
// Compute NURBS dicing rates
int diceu = 30, dicev = 30;
std::unique_ptr<Float[]> ueval(new Float[diceu]);
std::unique_ptr<Float[]> veval(new Float[dicev]);
std::unique_ptr<Point3f[]> evalPs(new Point3f[diceu * dicev]);
std::unique_ptr<Normal3f[]> evalNs(new Normal3f[diceu * dicev]);
int i;
for (i = 0; i < diceu; ++i)
ueval[i] = Lerp((float)i / (float)(diceu - 1), u0, u1);
for (i = 0; i < dicev; ++i)
veval[i] = Lerp((float)i / (float)(dicev - 1), v0, v1);
// Evaluate NURBS over grid of points
memset(evalPs.get(), 0, diceu * dicev * sizeof(Point3f));
memset(evalNs.get(), 0, diceu * dicev * sizeof(Point3f));
std::unique_ptr<Point2f[]> uvs(new Point2f[diceu * dicev]);
// Turn NURBS into triangles
std::unique_ptr<Homogeneous3[]> Pw(new Homogeneous3[nu * nv]);
if (isHomogeneous) {
for (int i = 0; i < nu * nv; ++i) {
Pw[i].x = P[4 * i];
Pw[i].y = P[4 * i + 1];
Pw[i].z = P[4 * i + 2];
Pw[i].w = P[4 * i + 3];
}
} else {
for (int i = 0; i < nu * nv; ++i) {
Pw[i].x = P[3 * i];
Pw[i].y = P[3 * i + 1];
Pw[i].z = P[3 * i + 2];
Pw[i].w = 1.;
}
}
for (int v = 0; v < dicev; ++v) {
for (int u = 0; u < diceu; ++u) {
uvs[(v * diceu + u)].x = ueval[u];
uvs[(v * diceu + u)].y = veval[v];
Vector3f dpdu, dpdv;
Point3f pt = NURBSEvaluateSurface(uorder, uknots, nu, ueval[u],
vorder, vknots, nv, veval[v],
Pw.get(), &dpdu, &dpdv);
evalPs[v * diceu + u].x = pt.x;
evalPs[v * diceu + u].y = pt.y;
evalPs[v * diceu + u].z = pt.z;
evalNs[v * diceu + u] = Normal3f(Normalize(Cross(dpdu, dpdv)));
}
}
// Generate points-polygons mesh
int nTris = 2 * (diceu - 1) * (dicev - 1);
std::unique_ptr<int[]> vertices(new int[3 * nTris]);
int *vertp = vertices.get();
// Compute the vertex offset numbers for the triangles
for (int v = 0; v < dicev - 1; ++v) {
for (int u = 0; u < diceu - 1; ++u) {
#define VN(u, v) ((v)*diceu + (u))
*vertp++ = VN(u, v);
*vertp++ = VN(u + 1, v);
*vertp++ = VN(u + 1, v + 1);
*vertp++ = VN(u, v);
*vertp++ = VN(u + 1, v + 1);
*vertp++ = VN(u, v + 1);
#undef VN
}
}
int nVerts = diceu * dicev;
return CreateTriangleMesh(o2w, w2o, reverseOrientation, nTris,
vertices.get(), nVerts, evalPs.get(), nullptr,
evalNs.get(), uvs.get(), nullptr);
}
void NURBS::Refine(vector<Reference<Shape> > &refined) const {
// Compute NURBS dicing rates
int diceu = 30, dicev = 30;
float *ueval = new float[diceu];
float *veval = new float[dicev];
Point *evalPs = new Point[diceu*dicev];
Normal *evalNs = new Normal[diceu*dicev];
int i;
for (i = 0; i < diceu; ++i)
ueval[i] = Lerp((float)i / (float)(diceu-1), umin, umax);
for (i = 0; i < dicev; ++i)
veval[i] = Lerp((float)i / (float)(dicev-1), vmin, vmax);
// Evaluate NURBS over grid of points
memset(evalPs, 0, diceu*dicev*sizeof(Point));
memset(evalNs, 0, diceu*dicev*sizeof(Point));
float *uvs = new float[2*diceu*dicev];
// Turn NURBS into triangles
Homogeneous3 *Pw = (Homogeneous3 *)P;
if (!isHomogeneous) {
Pw = (Homogeneous3 *)alloca(nu*nv*sizeof(Homogeneous3));
for (int i = 0; i < nu*nv; ++i) {
Pw[i].x = P[3*i];
Pw[i].y = P[3*i+1];
Pw[i].z = P[3*i+2];
Pw[i].w = 1.;
}
}
for (int v = 0; v < dicev; ++v) {
for (int u = 0; u < diceu; ++u) {
uvs[2*(v*diceu+u)] = ueval[u];
uvs[2*(v*diceu+u)+1] = veval[v];
Vector dPdu, dPdv;
Point pt = NURBSEvaluateSurface(uorder, uknot, nu, ueval[u],
vorder, vknot, nv, veval[v], Pw, &dPdu, &dPdv);
evalPs[v*diceu + u].x = pt.x;
evalPs[v*diceu + u].y = pt.y;
evalPs[v*diceu + u].z = pt.z;
evalNs[v*diceu + u] = Normal(Normalize(Cross(dPdu, dPdv)));
}
}
// Generate points-polygons mesh
int nTris = 2*(diceu-1)*(dicev-1);
int *vertices = new int[3 * nTris];
int *vertp = vertices;
// Compute the vertex offset numbers for the triangles
for (int v = 0; v < dicev-1; ++v) {
for (int u = 0; u < diceu-1; ++u) {
#define VN(u,v) ((v)*diceu+(u))
*vertp++ = VN(u, v);
*vertp++ = VN(u+1, v);
*vertp++ = VN(u+1, v+1);
*vertp++ = VN(u, v);
*vertp++ = VN(u+1, v+1);
*vertp++ = VN(u, v+1);
#undef VN
}
}
int nVerts = diceu*dicev;
ParamSet paramSet;
paramSet.AddInt("indices", vertices, 3*nTris);
paramSet.AddPoint("P", evalPs, nVerts);
paramSet.AddFloat("uv", uvs, 2 * nVerts);
paramSet.AddNormal("N", evalNs, nVerts);
refined.push_back(MakeShape("trianglemesh", ObjectToWorld,
reverseOrientation, paramSet));
// Cleanup from NURBS refinement
delete[] uvs;
delete[] ueval;
delete[] veval;
delete[] evalPs;
delete[] evalNs;
delete[] vertices;
}
