void Marker::draw(Mat &in, Scalar color, int lineWidth ,bool writeId)const
{
if (size()!=4) return;
cv::line( in,(*this)[0],(*this)[1],color,lineWidth,CV_AA);
cv::line( in,(*this)[1],(*this)[2],color,lineWidth,CV_AA);
cv::line( in,(*this)[2],(*this)[3],color,lineWidth,CV_AA);
cv::line( in,(*this)[3],(*this)[0],color,lineWidth,CV_AA);
cv::rectangle( in,(*this)[0]-Point2f(2,2),(*this)[0]+Point2f(2,2),Scalar(0,0,255,255),lineWidth,CV_AA);
cv::rectangle( in,(*this)[1]-Point2f(2,2),(*this)[1]+Point2f(2,2),Scalar(0,255,0,255),lineWidth,CV_AA);
cv::rectangle( in,(*this)[2]-Point2f(2,2),(*this)[2]+Point2f(2,2),Scalar(255,0,0,255),lineWidth,CV_AA);
if (writeId) {
char cad[100];
sprintf(cad,"id=%d",id);
//determine the centroid
Point cent(0,0);
for (int i=0;i<4;i++)
{
cent.x+=(*this)[i].x;
cent.y+=(*this)[i].y;
}
cent.x/=4.;
cent.y/=4.;
putText(in,cad, cent,FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255-color[0],255-color[1],255-color[2],255),2);
}
}
void XYRobot::initRobotCanvas()
{
origin = QPoint((scene->width()-p_width)/2,(scene->height()-p_height)/2);
//check item needed
if(pRect!=NULL)
{
//scene->removeItem(pRect);
}
QPen pen(QColor(124,124,124));
pRect = scene->addRect(origin.x(),origin.y(),p_width,p_height,pen);
QGraphicsTextItem* pTxt = scene->addText("0");
QPoint cent((origin.x()-10),origin.y()+p_height);
pTxt->setPos(cent);
pTxt->setDefaultTextColor(QColor(124,124,124));
txtPtr.append(pTxt);
QGraphicsTextItem* pTxt1 = scene->addText("Y");
cent = QPoint(origin.x()-10,origin.y()-10);
pTxt1->setPos(cent);
pTxt1->setDefaultTextColor(QColor(124,124,124));
txtPtr.append(pTxt1);
QGraphicsTextItem* pTxt2 = scene->addText("X");
cent = QPoint(origin.x()+p_width,origin.y()+p_height);
pTxt2->setPos(cent);
pTxt2->setDefaultTextColor(QColor(124,124,124));
txtPtr.append(pTxt1);
}
void Marker::draw(Mat &in, Scalar color, int lineWidth ,bool writeId)const
{
unsigned int n = size();
for (unsigned int i = 0; i < size(); i++) {
n = (i + 1 == size())? 0 : i+1;
if (n!=i) {
cv::line( in,(*this)[i],(*this)[n],color,lineWidth,CV_AA);
}
cv::rectangle( in,(*this)[i]-Point2f(2,2),(*this)[i]+Point2f(2,2),Scalar(0,85*(i%4),255*(i%2),255),lineWidth,CV_AA);
}
if (writeId) {
char cad[100];
sprintf(cad,"id=%d",id);
//determine the centroid
Point cent(0,0);
for (int i=0;i<4;i++)
{
cent.x+=(*this)[i].x;
cent.y+=(*this)[i].y;
}
cent.x/=4.;
cent.y/=4.;
putText(in,cad, cent,FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255-color[0],255-color[1],255-color[2],255),2);
}
}
Fur::TVector3<T> center( ) const {
Fur::TVector3<T> cent( a.position );
cent += b.position;
cent += c.position;
cent /= 3;
return cent;
}
int main()
{
Cents cent(5);
Cents neg_cent = -cent;
Cents add_cent = cent + 5;
std::cout << neg_cent.GetCents() << std::endl;
std::cout << add_cent.GetCents() << std::endl;
return 0;
}
cv::Point2f Marker::getCenter() const {
cv::Point2f cent(0, 0);
for (size_t i = 0; i < size(); i++) {
cent.x += (*this)[i].x;
cent.y += (*this)[i].y;
}
cent.x /= float(size());
cent.y /= float(size());
return cent;
}
// Parameter is a vector of vectors of points - each interior vector
// represents the 3 points that make up 1 face, in any order.
// Note: The polyhedron must be convex, with all faces given as triangles.
double polyhedronVol(vector<vector<point> > poly) {
int i,j;
point cent(0,0,0);
for (i=0; i<poly.size(); i++)
for (j=0; j<3; j++)
cent=cent+poly[i][j];
cent=cent*(1.0/(poly.size()*3));
double v=0;
for (i=0; i<poly.size(); i++)
v+=fabs(signedTetrahedronVol(cent,poly[i][0],poly[i][1],poly[i][2]));
return v;
}
void Marker::draw(cv::Mat& in, cv::Scalar color, int lineWidth, bool writeId, bool writeInfo) const
{
auto _to_string=[](int i){
std::stringstream str;str<<i;return str.str();
};
if (size() != 4)
return;
if (lineWidth == -1) // auto
lineWidth = static_cast<int>(std::max(1.f, float(in.cols) / 1000.f));
cv::line(in, (*this)[0], (*this)[1], color, lineWidth);
cv::line(in, (*this)[1], (*this)[2], color, lineWidth);
cv::line(in, (*this)[2], (*this)[3], color, lineWidth);
cv::line(in, (*this)[3], (*this)[0], color, lineWidth);
auto p2 = cv::Point2f(2.f * static_cast<float>(lineWidth), 2.f * static_cast<float>(lineWidth));
cv::rectangle(in, (*this)[0] - p2, (*this)[0] + p2, cv::Scalar(0, 0, 255, 255), -1);
cv::rectangle(in, (*this)[1] - p2, (*this)[1] + p2, cv::Scalar(0, 255, 0, 255), lineWidth);
cv::rectangle(in, (*this)[2] - p2, (*this)[2] + p2, cv::Scalar(255, 0, 0, 255), lineWidth);
if (writeId)
{
// determine the centroid
cv::Point cent(0, 0);
for (int i = 0; i < 4; i++)
{
cent.x += static_cast<int>((*this)[i].x);
cent.y += static_cast<int>((*this)[i].y);
}
cent.x /= 4;
cent.y /= 4;
std::string str;
if(writeInfo) str+= dict_info +":";
if(writeId)str+=_to_string(id);
cv::putText(in,str, cent, cv::FONT_HERSHEY_SIMPLEX, std::max(0.5f, float(lineWidth) * 0.3f),
cv::Scalar(255 - color[0], 255 - color[1], 255 - color[2], 255), std::max(lineWidth, 2));
}
}
void FExtrudeMod::ModifyObject(
TimeValue t, ModContext &mc, ObjectState *os, INode *node)
{
if (os->obj->IsSubClassOf(triObjectClassID)) {
TriObject *tobj = (TriObject*)os->obj;
Mesh &mesh = tobj->GetMesh();
Interval iv = FOREVER;
float a, s;
Point3 pt, center;
int c;
pblock->GetValue(PB_AMOUNT,t,a,iv);
pblock->GetValue(PB_SCALE,t,s,iv);
pblock->GetValue(PB_CENTER,t,c,iv);
base->GetValue(t,&pt,iv,CTRL_ABSOLUTE);
// Extrude the faces -- this just creates the new faces
mesh.ExtrudeFaces();
// Build normals of selected faces only
Tab<Point3> normals;
if (!c) {
normals.SetCount(mesh.getNumVerts());
for (int i=0; i<mesh.getNumVerts(); i++) {
normals[i] = Point3(0,0,0);
}
for (int i=0; i<mesh.getNumFaces(); i++) {
if (mesh.faceSel[i]) {
Point3 norm =
(mesh.verts[mesh.faces[i].v[1]]-mesh.verts[mesh.faces[i].v[0]]) ^
(mesh.verts[mesh.faces[i].v[2]]-mesh.verts[mesh.faces[i].v[1]]);
for (int j=0; j<3; j++) {
normals[mesh.faces[i].v[j]] += norm;
}
}
}
for (int i=0; i<mesh.getNumVerts(); i++) {
normals[i] = Normalize(normals[i]);
}
} else {
// Compute the center point
base->GetValue(t,¢er,iv,CTRL_ABSOLUTE);
}
// Mark vertices used by selected faces
BitArray sel;
sel.SetSize(mesh.getNumVerts());
for (int i=0; i<mesh.getNumFaces(); i++) {
if (mesh.faceSel[i]) {
for (int j=0; j<3; j++) sel.Set(mesh.faces[i].v[j],TRUE);
}
}
// Move selected verts
for (int i=0; i<mesh.getNumVerts(); i++) {
if (sel[i]) {
if (!c) {
mesh.verts[i] += normals[i]*a;
} else {
Point3 vect = Normalize((mesh.verts[i] * (*mc.tm))
- center);
mesh.verts[i] += vect*a;
}
}
}
// Scale verts
if (s!=100.0f) {
s /= 100.0f;
AdjEdgeList ae(mesh);
AdjFaceList af(mesh,ae);
FaceClusterList clust(mesh.faceSel,af);
// Make sure each vertex is only scaled once.
BitArray done;
done.SetSize(mesh.getNumVerts());
// scale each cluster independently
for (int i=0; (DWORD)i<clust.count; i++) {
// First determine cluster center
Point3 cent(0,0,0);
int ct=0;
for (int j=0; j<mesh.getNumFaces(); j++) {
if (clust[j]==(DWORD)i) {
for (int k=0; k<3; k++) {
cent += mesh.verts[mesh.faces[j].v[k]];
ct++;
}
}
}
if (ct) cent /= float(ct);
// Now scale the cluster about its center
for (int j=0; j<mesh.getNumFaces(); j++) {
if (clust[j]==(DWORD)i) {
for (int k=0; k<3; k++) {
int index = mesh.faces[j].v[k];
if (done[index]) continue;
done.Set(index);
mesh.verts[index] =
(mesh.verts[index]-cent)*s + cent;
}
}
}
}
}
mesh.InvalidateTopologyCache ();
os->obj->UpdateValidity(GEOM_CHAN_NUM,iv);
}
}
/* static public */
bool
Centroid::getCentroid(const Geometry& geom, Coordinate& pt)
{
Centroid cent(geom);
return cent.getCentroid(pt);
}
void show_mechs_damage(dbref player, void *data, char *buffer)
{
MECH *mech = data;
coolmenu *c = NULL;
int i, j, v1, v2;
char buf[MBUF_SIZE];
char buf2[MBUF_SIZE];
int isds;
TECHCOMMANDD;
if (unit_is_fixable(mech))
make_damage_table(mech);
else
make_scrap_table(mech);
DOCHECK(!damage_last &&
MechType(mech) == CLASS_MECH,
"The 'mech is in pristine condition!");
DOCHECK(!damage_last, "It's in pristine condition!");
addline();
cent(tprintf("Damage for %s", GetMechID(mech)));
addline();
for (i = 0; i < damage_last; i++) {
v1 = damage_table[i][1];
v2 = damage_table[i][2];
switch (damage_table[i][0]) {
case REATTACH:
case DETACH:
case RESEAL:
case REPLACESUIT:
strcpy(buf, repair_need_msgs[(int) damage_table[i][0]]);
break;
case REPAIRP:
case REPAIRP_T:
case REPAIRG:
case ENHCRIT_MISC:
case ENHCRIT_FOCUS:
case ENHCRIT_CRYSTAL:
case ENHCRIT_BARREL:
case ENHCRIT_AMMOB:
case ENHCRIT_RANGING:
case ENHCRIT_AMMOM:
case SCRAPP:
case SCRAPG:
sprintf(buf, repair_need_msgs[(int) damage_table[i][0]],
pos_part_name(mech, v1, v2));
break;
case RELOAD:
sprintf(buf, repair_need_msgs[(int) damage_table[i][0]],
pos_part_name(mech, v1, v2), FullAmmo(mech, v1,
v2) - GetPartData(mech, v1, v2));
break;
case UNLOAD:
sprintf(buf, repair_need_msgs[(int) damage_table[i][0]],
pos_part_name(mech, v1, v2), GetPartData(mech, v1, v2));
break;
case FIXARMOR:
case FIXARMOR_R:
case FIXINTERNAL:
sprintf(buf, repair_need_msgs[(int) damage_table[i][0]],
damage_table[i][2]);
break;
}
j = is_under_repair(mech, i);
sprintf(buf2, "%%ch%s%-2d:%s %%cn%s%s", j ? "%cg" : "%cy", i + 1,
ShortArmorSectionString(MechType(mech), MechMove(mech), v1),
buf, j ? " (*)" : "");
vsi(buf2);
}
addline();
vsi("(*) / %ch%cgGreen%cn = Job already done. %ch%cyYellow%cn = To be done.");
addline();
ShowCoolMenu(player, c);
KillCoolMenu(c);
}
SEXP kmeansMatrixEuclid(MatrixType x, index_type n, index_type m,
SEXP pcen, SEXP pclust, SEXP pclustsizes,
SEXP pwss, SEXP itermax)
{
index_type j, col, nchange;
int maxiters = Rf_asInteger(itermax);
SEXP Riter;
Rf_protect(Riter = Rf_allocVector(INTSXP, 1));
int *iter = INTEGER(Riter);
iter[0] = 0;
BigMatrix *pcent = reinterpret_cast<BigMatrix*>(R_ExternalPtrAddr(pcen));
MatrixAccessor<double> cent(*pcent);
BigMatrix *Pclust = reinterpret_cast<BigMatrix*>(R_ExternalPtrAddr(pclust));
MatrixAccessor<int> clust(*Pclust);
BigMatrix *Pclustsizes = reinterpret_cast<BigMatrix*>(R_ExternalPtrAddr(pclustsizes));
MatrixAccessor<double> clustsizes(*Pclustsizes);
BigMatrix *Pwss = reinterpret_cast<BigMatrix*>(R_ExternalPtrAddr(pwss));
MatrixAccessor<double> ss(*Pwss);
int k = (int) pcent->nrow(); // number of clusters
int cl, bestcl, oldcluster, newcluster;
int done = 0;
double temp;
vector<double> d(k); // Vector of distances, internal only.
vector<double> temp1(k);
vector<vector<double> > tempcent(m, temp1); // For copy of global centroids k x m
// At this point I can use [][] to access things, with ss[0][cl]
// being used for the vectors, for example.
// Before starting the loop, we only have cent (centers) as passed into the function.
// Calculate clust and clustsizes, then update cent as centroids.
for (cl=0; cl<k; cl++) clustsizes[0][cl] = 0.0;
for (j=0; j<n; j++) {
bestcl = 0;
for (cl=0; cl<k; cl++) {
d[cl] = 0.0;
for (col=0; col<m; col++) {
temp = (double)x[col][j] - cent[col][cl];
d[cl] += temp * temp;
}
if (d[cl]<d[bestcl]) bestcl = cl;
}
clust[0][j] = bestcl + 1; // Saving the R cluster number, not the C index.
clustsizes[0][bestcl]++;
for (col=0; col<m; col++)
tempcent[col][bestcl] += (double)x[col][j];
}
for (cl=0; cl<k; cl++)
for (col=0; col<m; col++)
cent[col][cl] = tempcent[col][cl] / clustsizes[0][cl];
do {
nchange = 0;
for (j=0; j<n; j++) { // For each of my points, this is offset from hash position
oldcluster = clust[0][j] - 1;
bestcl = 0;
for (cl=0; cl<k; cl++) { // Consider each of the clusters
d[cl] = 0.0; // We'll get the distance to this cluster.
for (col=0; col<m; col++) { // Loop over the dimension of the data
temp = (double)x[col][j] - cent[col][cl];
d[cl] += temp * temp;
}
if (d[cl]<d[bestcl]) bestcl = cl;
} // End of looking over the clusters for this j
if (d[bestcl] < d[oldcluster]) { // MADE A CHANGE!
newcluster = bestcl;
clust[0][j] = newcluster + 1;
nchange++;
clustsizes[0][newcluster]++;
clustsizes[0][oldcluster]--;
for (col=0; col<m; col++) {
cent[col][oldcluster] += ( cent[col][oldcluster] - (double)x[col][j] ) / clustsizes[0][oldcluster];
cent[col][newcluster] += ( (double)x[col][j] - cent[col][newcluster] ) / clustsizes[0][newcluster];
}
}
} // End of this pass over my points.
iter[0]++;
if ( (nchange==0) || (iter[0]>=maxiters) ) done = 1;
} while (done==0);
// Collect the sums of squares now that we're done.
for (cl=0; cl<k; cl++) ss[0][cl] = 0.0;
for (j=0; j<n; j++) {
for (col=0; col<m; col++) {
cl = clust[0][j]-1;
temp = (double)x[col][j] - cent[col][cl];
ss[0][cl] += temp * temp;
}
}
Rf_unprotect(1);
return(Riter);
}