struct complex cDiv(struct complex C1, struct complex C2)
{
struct complex temp;
temp.Re = (C1.Re*C2.Re + C1.Im*C2.Im)/cAbs(C2);
temp.Im = (C2.Re*C1.Im - C2.Im*C1.Re)/cAbs(C2);
return temp;
}
//==============================================================================
void cShapeTorus::setSize(const double& a_innerRadius,
const double& a_outerRadius)
{
// set new dimensions
m_innerRadius = cAbs(a_innerRadius);
m_outerRadius = cAbs(a_outerRadius);
// update bounding box
updateBoundaryBox();
// update display list
markForUpdate(false);
}
//===========================================================================
void cShapeBox::setSize(const double& a_sizeX, const double& a_sizeY, const double& a_sizeZ)
{
// set dimensions
m_hSizeX = 0.5 * cAbs(a_sizeX);
m_hSizeY = 0.5 * cAbs(a_sizeY);
m_hSizeZ = 0.5 * cAbs(a_sizeZ);
// update bounding box
updateBoundaryBox();
// invalidate display list
invalidateDisplayList(false);
}
int main()
{
char s[100];
double a, b;
struct complex C1, C2;
printf("Введите комплексное число в формате a, b: ");
scanf("%lf%lf", &a, &b);
C1 = cRead(a, b);
cPrint(C1);
printf("Введите комплексное число в формате a,b: ");
scanf("%lf%lf", &a, &b);
C2 = cRead(a,b);
cPrint(C2);
printf("РЎСѓРјРјР°: ");
cPrint(cAdd(C1, C2));
printf("Разность: ");
cPrint(cSub(C1, C2));
printf("Произведение: ");
cPrint(cMul(C1, C2));
printf("Частное: ");
cPrint(cDiv(C1, C2));
printf("Модуль 1-ого: %f: \n", cAbs(C1));
printf("Аргумент 1-ого: %f: \n", cArg(C1));
printf("Сопряжённое 1-ого: "); cPrint(cConj(C1));
printf("Re 1-РѕРіРѕ: %f: \n", cReal(C1));
printf("Im 1-РѕРіРѕ: %f: \n", cImag(C1));
return 0;
}
//===========================================================================
void cShapeSphere::setRadius(const double& a_radius)
{
// set new radius
m_radius = cAbs(a_radius);
// update bounding box
updateBoundaryBox();
// invalidate display list
invalidateDisplayList();
}
//===========================================================================
void cShapeMatching3dofPointer::setWorkspaceScaleFactor(const double& a_workspaceScaleFactor)
{
// make sure that input value is bigger than zero
double value = cAbs(a_workspaceScaleFactor);
if (value == 0) { return; }
// update scale factor
m_workspaceScaleFactor = value;
// compute the new scale factor between the workspace of the tool
// and one of the haptic device
m_workspaceRadius = m_workspaceScaleFactor * m_device->getSpecifications().m_workspaceRadius;
}
//===========================================================================
cShapeSphere::cShapeSphere(const double& a_radius,
cMaterial* a_material)
{
// initialize radius of sphere
m_radius = cAbs(a_radius);
// set material properties
if (a_material == NULL)
{
m_material = new cMaterial();
m_material->setShininess(100);
m_material->setWhite();
}
else
{
m_material = a_material;
}
};
bool ch_proxyPointForceAlgo::computeNextProxyPositionWithContraints00(const cVector3d& a_goalGlobalPos, const cVector3d& a_toolVel)
{
// We define the goal position of the proxy.
cVector3d goalGlobalPos = a_goalGlobalPos;
// To address numerical errors of the computer, we make sure to keep the proxy
// slightly above any triangle and not directly on it. If we are using a radius of
// zero, we need to define a default small value for epsilon
m_epsilonInitialValue = cAbs(0.0001 * m_radius);
if (m_epsilonInitialValue < m_epsilonBaseValue)
{
m_epsilonInitialValue = m_epsilonBaseValue;
}
// The epsilon value is dynamic (can be reduced). We set it to its initial
// value if the proxy is not touching any triangle.
if (m_numContacts == 0)
{
m_epsilon = m_epsilonInitialValue;
m_slipping = true;
}
// If the distance between the proxy and the goal position (device) is
// very small then we can be considered done.
if (!m_useDynamicProxy)
{
if (goalAchieved(m_proxyGlobalPos, goalGlobalPos))
{
m_nextBestProxyGlobalPos = m_proxyGlobalPos;
m_algoCounter = 0;
return (false);
}
}
// compute the normalized form of the vector going from the
// current proxy position to the desired goal position
// compute the distance between the proxy and the goal positions
double distanceProxyGoal = cDistance(m_proxyGlobalPos, goalGlobalPos);
// A vector from the proxy to the goal
cVector3d vProxyToGoal;
cVector3d vProxyToGoalNormalized;
bool proxyAndDeviceEqual;
if (distanceProxyGoal > m_epsilon)
{
// proxy and goal are sufficiently distant from each other
goalGlobalPos.subr(m_proxyGlobalPos, vProxyToGoal);
vProxyToGoal.normalizer(vProxyToGoalNormalized);
proxyAndDeviceEqual = false;
}
else
{
// proxy and goal are very close to each other
vProxyToGoal.zero();
vProxyToGoalNormalized.zero();
proxyAndDeviceEqual = true;
}
// Test whether the path from the proxy to the goal is obstructed.
// For this we create a segment that goes from the proxy position to
// the goal position plus a little extra to take into account the
// physical radius of the proxy.
cVector3d targetPos;
if (m_useDynamicProxy)
{
targetPos = goalGlobalPos;
}
else
{
targetPos = goalGlobalPos +
cMul(m_epsilonCollisionDetection, vProxyToGoalNormalized);
}
// setup collision detector
// m_radius is the radius of the proxy
m_collisionSettings.m_collisionRadius = m_radius;
// Search for a collision between the first segment (proxy-device)
// and the environment.
m_collisionSettings.m_adjustObjectMotion = m_useDynamicProxy;
m_collisionRecorderConstraint0.clear();
bool hit = m_world->computeCollisionDetection(m_proxyGlobalPos,
targetPos,
m_collisionRecorderConstraint0,
m_collisionSettings);
// check if collision occurred between proxy and goal positions.
double collisionDistance;
if (hit)
{
collisionDistance = sqrt(m_collisionRecorderConstraint0.m_nearestCollision.m_squareDistance);
if (m_useDynamicProxy)
{
// retrieve new position of proxy
cVector3d posLocal = m_collisionRecorderConstraint0.m_nearestCollision.m_adjustedSegmentAPoint;
cGenericObject* obj = m_collisionRecorderConstraint0.m_nearestCollision.m_object;
cVector3d posGlobal = cAdd(obj->getGlobalPos(), cMul( obj->getGlobalRot(), posLocal ));
m_proxyGlobalPos = posGlobal;
distanceProxyGoal = cDistance(m_proxyGlobalPos, goalGlobalPos);
goalGlobalPos.subr(m_proxyGlobalPos, vProxyToGoal);
vProxyToGoal.normalizer(vProxyToGoalNormalized);
}
if (collisionDistance > (distanceProxyGoal + CHAI_SMALL))
{
// just to make sure that the collision point lies on the proxy-goal segment and not outside of it
hit = false;
}
if (hit)
{
// a collision has occurred and we check if the distance from the
// proxy to the collision is smaller than epsilon. If yes, then
// we reduce the epsilon term in order to avoid possible "pop through"
// effect if we suddenly push the proxy "up" again.
if (collisionDistance < m_epsilon)
{
m_epsilon = collisionDistance;
if (m_epsilon < m_epsilonMinimalValue)
{
m_epsilon = m_epsilonMinimalValue;
}
}
}
}
// If no collision occurs, then we move the proxy to its goal, and we're done
if (!hit)
{
m_numContacts = 0;
m_algoCounter = 0;
m_slipping = true;
m_nextBestProxyGlobalPos = goalGlobalPos;
return (false);
}
// a first collision has occurred
m_algoCounter = 1;
//-----------------------------------------------------------------------
// FIRST COLLISION OCCURES:
//-----------------------------------------------------------------------
// We want the center of the proxy to move as far toward the triangle as it can,
// but we want it to stop when the _sphere_ representing the proxy hits the
// triangle. We want to compute how far the proxy center will have to
// be pushed _away_ from the collision point - along the vector from the proxy
// to the goal - to keep a distance m_radius between the proxy center and the
// triangle.
//
// So we compute the cosine of the angle between the normal and proxy-goal vector...
double cosAngle = vProxyToGoalNormalized.dot(m_collisionRecorderConstraint0.m_nearestCollision.m_globalNormal);
// Now we compute how far away from the collision point - _backwards_
// along vProxyGoal - we have to put the proxy to keep it from penetrating
// the triangle.
//
// If only ASCII art were a little more expressive...
double distanceTriangleProxy = m_epsilon / cAbs(cosAngle);
if (distanceTriangleProxy > collisionDistance) {
distanceTriangleProxy = cMax(collisionDistance, m_epsilon);
}
// We compute the projection of the vector between the proxy and the collision
// point onto the normal of the triangle. This is the direction in which
// we'll move the _goal_ to "push it away" from the triangle (to account for
// the radius of the proxy).
// A vector from the most recent collision point to the proxy
cVector3d vCollisionToProxy;
m_proxyGlobalPos.subr(m_contactPoint0->m_globalPos, vCollisionToProxy);
// Move the proxy to the collision point, minus the distance along the
// movement vector that we computed above.
//
// Note that we're adjusting the 'proxy' variable, which is just a local
// copy of the proxy position. We still might decide not to move the
// 'real' proxy due to friction.
cVector3d vColNextGoal;
vProxyToGoalNormalized.mulr(-distanceTriangleProxy, vColNextGoal);
cVector3d nextProxyPos;
m_contactPoint0->m_globalPos.addr(vColNextGoal, nextProxyPos);
// we can now set the next position of the proxy
m_nextBestProxyGlobalPos = nextProxyPos;
// If the distance between the proxy and the goal position (device) is
// very small then we can be considered done.
if (goalAchieved(goalGlobalPos, nextProxyPos))
{
m_numContacts = 1;
m_algoCounter = 0;
return (true);
}
return (true);
}
bool ch_proxyPointForceAlgo::computeNextProxyPositionWithContraints22(const cVector3d& a_goalGlobalPos, const cVector3d& a_toolVel)
{
// The proxy is now constrained by two triangles and can only move along
// a virtual line; we now calculate the nearest point to the original
// goal (device position) along this line by projecting the ideal
// goal onto the line.
//
// The line is expressed by the cross product of both surface normals,
// which have both been oriented to point away from the device
cVector3d line;
m_collisionRecorderConstraint0.m_nearestCollision.m_globalNormal.crossr(m_collisionRecorderConstraint1.m_nearestCollision.m_globalNormal, line);
// check result.
if (line.equals(cVector3d(0,0,0)))
{
m_nextBestProxyGlobalPos = m_proxyGlobalPos;
m_algoCounter = 0;
m_numContacts = 2;
return (false);
}
line.normalize();
// Compute the projection of the device position (goal) onto the line; this
// gives us the new goal position.
cVector3d goalGlobalPos = cProjectPointOnLine(a_goalGlobalPos, m_proxyGlobalPos, line);
// A vector from the proxy to the goal
cVector3d vProxyToGoal;
goalGlobalPos.subr(m_proxyGlobalPos, vProxyToGoal);
// If the distance between the proxy and the goal position (device) is
// very small then we can be considered done.
if (goalAchieved(m_proxyGlobalPos, goalGlobalPos))
{
m_nextBestProxyGlobalPos = m_proxyGlobalPos;
m_algoCounter = 0;
m_numContacts = 2;
return (false);
}
// compute the normalized form of the vector going from the
// current proxy position to the desired goal position
cVector3d vProxyToGoalNormalized;
vProxyToGoal.normalizer(vProxyToGoalNormalized);
// Test whether the path from the proxy to the goal is obstructed.
// For this we create a segment that goes from the proxy position to
// the goal position plus a little extra to take into account the
// physical radius of the proxy.
cVector3d targetPos = goalGlobalPos +
cMul(m_epsilonCollisionDetection, vProxyToGoalNormalized);
// setup collision detector
m_collisionSettings.m_collisionRadius = m_radius;
// search for collision
m_collisionSettings.m_adjustObjectMotion = false;
m_collisionRecorderConstraint2.clear();
bool hit = m_world->computeCollisionDetection( m_proxyGlobalPos,
targetPos,
m_collisionRecorderConstraint2,
m_collisionSettings);
// check if collision occurred between proxy and goal positions.
double collisionDistance;
if (hit)
{
collisionDistance = sqrt(m_collisionRecorderConstraint2.m_nearestCollision.m_squareDistance);
if (collisionDistance > (cDistance(m_proxyGlobalPos, goalGlobalPos) + CHAI_SMALL))
{
hit = false;
}
else
{
// a collision has occurred and we check if the distance from the
// proxy to the collision is smaller than epsilon. If yes, then
// we reduce the epsilon term in order to avoid possible "pop through"
// effect if we suddenly push the proxy "up" again.
if (collisionDistance < m_epsilon)
{
m_epsilon = collisionDistance;
if (m_epsilon < m_epsilonMinimalValue)
{
m_epsilon = m_epsilonMinimalValue;
}
}
}
}
// If no collision occurs, we move the proxy to its goal, unless
// friction prevents us from doing so
if (!hit)
{
cVector3d normal = cMul(0.5,cAdd(m_collisionRecorderConstraint0.m_nearestCollision.m_globalNormal,
m_collisionRecorderConstraint1.m_nearestCollision.m_globalNormal));
testFrictionAndMoveProxy(goalGlobalPos,
m_proxyGlobalPos,
normal,
m_collisionRecorderConstraint1.m_nearestCollision.m_triangle->getParent(), a_toolVel);
m_numContacts = 2;
m_algoCounter = 0;
return (false);
}
//-----------------------------------------------------------------------
// THIRD COLLISION OCCURES:
//-----------------------------------------------------------------------
// We want the center of the proxy to move as far toward the triangle as it can,
// but we want it to stop when the _sphere_ representing the proxy hits the
// triangle. We want to compute how far the proxy center will have to
// be pushed _away_ from the collision point - along the vector from the proxy
// to the goal - to keep a distance m_radius between the proxy center and the
// triangle.
//
// So we compute the cosine of the angle between the normal and proxy-goal vector...
double cosAngle = vProxyToGoalNormalized.dot(m_collisionRecorderConstraint2.m_nearestCollision.m_globalNormal);
// Now we compute how far away from the collision point - _backwards_
// along vProxyGoal - we have to put the proxy to keep it from penetrating
// the triangle.
//
// If only ASCII art were a little more expressive...
double distanceTriangleProxy = m_epsilon / cAbs(cosAngle);
if (distanceTriangleProxy > collisionDistance) {
distanceTriangleProxy = cMax(collisionDistance, m_epsilon);
}
// We compute the projection of the vector between the proxy and the collision
// point onto the normal of the triangle. This is the direction in which
// we'll move the _goal_ to "push it away" from the triangle (to account for
// the radius of the proxy).
// A vector from the most recent collision point to the proxy
cVector3d vCollisionToProxy;
m_proxyGlobalPos.subr(m_contactPoint2->m_globalPos, vCollisionToProxy);
// Move the proxy to the collision point, minus the distance along the
// movement vector that we computed above.
//
// Note that we're adjusting the 'proxy' variable, which is just a local
// copy of the proxy position. We still might decide not to move the
// 'real' proxy due to friction.
cVector3d vColNextGoal;
vProxyToGoalNormalized.mulr(-distanceTriangleProxy, vColNextGoal);
cVector3d nextProxyPos;
m_contactPoint2->m_globalPos.addr(vColNextGoal, nextProxyPos);
// we can now set the next position of the proxy
m_nextBestProxyGlobalPos = nextProxyPos;
m_algoCounter = 0;
m_numContacts = 3;
// TODO: There actually should be a third friction test to see if we
// can make it to our new goal position, but this is generally such a
// small movement in one iteration that it's irrelevant...
return (true);
}
//===========================================================================
void cSpotLight::setShadowMapProperties(const double& a_nearClippingPlane,
const double& a_farClippingPlane)
{
m_shadowNearClippingPlane = cMin(cAbs(a_nearClippingPlane), cAbs(a_farClippingPlane));
m_shadowFarClippingPlane = cMax(cAbs(a_nearClippingPlane), cAbs(a_farClippingPlane));
}
