void Perturb_Normal(Vector3d& Layer_Normal, const TNORMAL *Tnormal, const Vector3d& EPoint, Intersection *Intersection, const Ray *ray, TraceThreadData *Thread)
{
Vector3d TPoint,P1;
DBL value1,Amount;
int i;
shared_ptr<NormalBlendMap> Blend_Map;
if (Tnormal==NULL)
{
return;
}
/* If normal_map present, use it and return */
Blend_Map = std::tr1::dynamic_pointer_cast<NormalBlendMap>(Tnormal->Blend_Map);
if (Blend_Map != NULL)
{
if (Tnormal->Type == UV_MAP_PATTERN)
{
Vector2d UV_Coords;
/* Don't bother warping, simply get the UV vect of the intersection */
Intersection->Object->UVCoord(UV_Coords, Intersection, Thread);
TPoint[X] = UV_Coords[U];
TPoint[Y] = UV_Coords[V];
TPoint[Z] = 0;
Perturb_Normal(Layer_Normal,Blend_Map->Blend_Map_Entries[0].Vals,TPoint,Intersection,ray,Thread);
Layer_Normal.normalize();
Intersection->PNormal = Layer_Normal; /* -hdf- June 98 */
return;
}
else if (Tnormal->Type != AVERAGE_PATTERN)
{
const NormalBlendMapEntry *Prev, *Cur;
DBL prevWeight, curWeight;
/* NK 19 Nov 1999 added Warp_EPoint */
Warp_EPoint (TPoint, EPoint, Tnormal);
value1 = Evaluate_TPat(Tnormal, TPoint, Intersection, ray, Thread);
Blend_Map->Search (value1,Prev,Cur,prevWeight,curWeight);
Warp_Normal(Layer_Normal,Layer_Normal, Tnormal, Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
P1 = Layer_Normal;
Warp_EPoint (TPoint, EPoint, Tnormal);
Perturb_Normal(Layer_Normal,Cur->Vals,TPoint,Intersection,ray,Thread);
if (Prev != Cur)
{
Perturb_Normal(P1,Prev->Vals,TPoint,Intersection,ray,Thread);
Layer_Normal = prevWeight * P1 + curWeight * Layer_Normal;
}
UnWarp_Normal(Layer_Normal,Layer_Normal, Tnormal, Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
Layer_Normal.normalize();
Intersection->PNormal = Layer_Normal; /* -hdf- June 98 */
return;
}
// TODO - what if Tnormal->Type == AVERAGE_PATTERN?
}
/* No normal_map. */
if (Tnormal->Type <= LAST_NORM_ONLY_PATTERN)
{
Warp_Normal(Layer_Normal,Layer_Normal, Tnormal,
Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
Warp_EPoint (TPoint, EPoint, Tnormal);
switch (Tnormal->Type)
{
case BITMAP_PATTERN:
bump_map (TPoint, Tnormal, Layer_Normal);
break;
case BUMPS_PATTERN:
bumps (TPoint, Tnormal, Layer_Normal);
break;
case DENTS_PATTERN:
dents (TPoint, Tnormal, Layer_Normal, Thread);
break;
case RIPPLES_PATTERN:
ripples (TPoint, Tnormal, Layer_Normal, Thread);
break;
case WAVES_PATTERN:
waves (TPoint, Tnormal, Layer_Normal, Thread);
break;
case WRINKLES_PATTERN:
wrinkles (TPoint, Tnormal, Layer_Normal);
break;
case QUILTED_PATTERN:
quilted (TPoint, Tnormal, Layer_Normal);
break;
case FACETS_PATTERN:
facets (TPoint, Tnormal, Layer_Normal, Thread);
break;
case AVERAGE_PATTERN:
Do_Average_Normals (TPoint, Tnormal, Layer_Normal, Intersection, ray, Thread);
break;
default:
throw POV_EXCEPTION_STRING("Normal pattern not yet implemented.");
}
UnWarp_Normal(Layer_Normal,Layer_Normal, Tnormal,
Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
}
else
{
shared_ptr<SlopeBlendMap> slopeMap = std::tr1::dynamic_pointer_cast<SlopeBlendMap>(Tnormal->Blend_Map);
Warp_Normal(Layer_Normal,Layer_Normal, Tnormal,
Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
// TODO FIXME - two magic fudge factors
Amount=Tnormal->Amount * -5.0; /*fudge factor*/
Amount*=0.02/Tnormal->Delta; /* NK delta */
/* warp the center point first - this is the last warp */
Warp_EPoint(TPoint,EPoint,Tnormal);
for(i=0; i<=3; i++)
{
P1 = TPoint + (DBL)Tnormal->Delta * Pyramid_Vect[i]; /* NK delta */
value1 = Do_Slope_Map(Evaluate_TPat(Tnormal, P1, Intersection, ray, Thread), slopeMap.get());
Layer_Normal += (value1*Amount) * Pyramid_Vect[i];
}
UnWarp_Normal(Layer_Normal,Layer_Normal,Tnormal,
Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
}
if ( Intersection )
Intersection->PNormal = Layer_Normal; /* -hdf- June 98 */
}
int main(int argc, char** argv)
{
// Initialize some global data
Aria::init();
// If you want ArLog to print "Verbose" level messages uncomment this:
//ArLog::init(ArLog::StdOut, ArLog::Verbose);
// This object parses program options from the command line
ArArgumentParser parser(&argc, argv);
// Load some default values for command line arguments from /etc/Aria.args
// (Linux) or the ARIAARGS environment variable.
parser.loadDefaultArguments();
// Central object that is an interface to the robot and its integrated
// devices, and which manages control of the robot by the rest of the program.
ArRobot robot;
// Object that connects to the robot or simulator using program options
ArRobotConnector robotConnector(&parser, &robot);
// If the robot has an Analog Gyro, this object will activate it, and
// if the robot does not automatically use the gyro to correct heading,
// this object reads data from it and corrects the pose in ArRobot
ArAnalogGyro gyro(&robot);
// Connect to the robot, get some initial data from it such as type and name,
// and then load parameter files for this robot.
if (!robotConnector.connectRobot())
{
// Error connecting:
// if the user gave the -help argumentp, then just print out what happened,
// and continue so options can be displayed later.
if (!parser.checkHelpAndWarnUnparsed())
{
ArLog::log(ArLog::Terse, "Could not connect to robot, will not have parameter file so options displayed later may not include everything");
}
// otherwise abort
else
{
ArLog::log(ArLog::Terse, "Error, could not connect to robot.");
Aria::logOptions();
Aria::exit(1);
}
}
// Connector for laser rangefinders
ArLaserConnector laserConnector(&parser, &robot, &robotConnector);
// Connector for compasses
ArCompassConnector compassConnector(&parser);
// Parse the command line options. Fail and print the help message if the parsing fails
// or if the help was requested with the -help option
if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed())
{
Aria::logOptions();
exit(1);
}
// Used to access and process sonar range data
ArSonarDevice sonarDev;
// Used to perform actions when keyboard keys are pressed
ArKeyHandler keyHandler;
Aria::setKeyHandler(&keyHandler);
// ArRobot contains an exit action for the Escape key. It also
// stores a pointer to the keyhandler so that other parts of the program can
// use the same keyhandler.
robot.attachKeyHandler(&keyHandler);
printf("You may press escape to exit\n");
// Attach sonarDev to the robot so it gets data from it.
robot.addRangeDevice(&sonarDev);
// Start the robot task loop running in a new background thread. The 'true' argument means if it loses
// connection the task loop stops and the thread exits.
robot.runAsync(true);
// Connect to the laser(s) if lasers were configured in this robot's parameter
// file or on the command line, and run laser processing thread if applicable
// for that laser class. (For the purposes of this demo, add all
// possible lasers to ArRobot's list rather than just the ones that were
// specified with the connectLaser option (so when you enter laser mode, you
// can then interactively choose which laser to use from the list which will
// show both connected and unconnected lasers.)
if (!laserConnector.connectLasers(false, false, true))
{
printf("Could not connect to lasers... exiting\n");
Aria::exit(2);
}
// Create and connect to the compass if the robot has one.
ArTCM2 *compass = compassConnector.create(&robot);
if(compass && !compass->blockingConnect()) {
compass = NULL;
}
// Sleep for a second so some messages from the initial responses
// from robots and cameras and such can catch up
ArUtil::sleep(1000);
// We need to lock the robot since we'll be setting up these modes
// while the robot task loop thread is already running, and they
// need to access some shared data in ArRobot.
robot.lock();
// now add all the modes for this demo
// these classes are defined in ArModes.cpp in ARIA's source code.
ArModeLaser laser(&robot, "laser", 'l', 'L');
ArModeTeleop teleop(&robot, "teleop", 't', 'T');
ArModeUnguardedTeleop unguardedTeleop(&robot, "unguarded teleop", 'u', 'U');
ArModeWander wander(&robot, "wander", 'w', 'W');
ArModeGripper gripper(&robot, "gripper", 'g', 'G');
ArModeCamera camera(&robot, "camera", 'c', 'C');
ArModeSonar sonar(&robot, "sonar", 's', 'S');
ArModeBumps bumps(&robot, "bumps", 'b', 'B');
ArModePosition position(&robot, "position", 'p', 'P', &gyro);
ArModeIO io(&robot, "io", 'i', 'I');
ArModeActs actsMode(&robot, "acts", 'a', 'A');
ArModeCommand command(&robot, "command", 'd', 'D');
ArModeTCM2 tcm2(&robot, "tcm2", 'm', 'M', compass);
// activate the default mode
teleop.activate();
// turn on the motors
robot.comInt(ArCommands::ENABLE, 1);
robot.unlock();
// Block execution of the main thread here and wait for the robot's task loop
// thread to exit (e.g. by robot disconnecting, escape key pressed, or OS
// signal)
robot.waitForRunExit();
Aria::exit(0);
}
void Perturb_Normal(VECTOR Layer_Normal, const TNORMAL *Tnormal, const VECTOR EPoint, Intersection *Intersection, const Ray *ray, TraceThreadData *Thread)
{
VECTOR TPoint,P1;
DBL value1,value2,Amount;
int i;
BLEND_MAP *Blend_Map;
BLEND_MAP_ENTRY *Prev, *Cur;
if (Tnormal==NULL)
{
return;
}
/* If normal_map present, use it and return */
if ((Blend_Map=Tnormal->Blend_Map) != NULL)
{
if ((Blend_Map->Type == NORMAL_TYPE) && (Tnormal->Type == UV_MAP_PATTERN))
{
UV_VECT UV_Coords;
Cur = &(Tnormal->Blend_Map->Blend_Map_Entries[0]);
/* Don't bother warping, simply get the UV vect of the intersection */
Intersection->Object->UVCoord(UV_Coords, Intersection, Thread);
TPoint[X] = UV_Coords[U];
TPoint[Y] = UV_Coords[V];
TPoint[Z] = 0;
Perturb_Normal(Layer_Normal,Cur->Vals.Tnormal,TPoint,Intersection,ray,Thread);
VNormalizeEq(Layer_Normal);
Assign_Vector(Intersection->PNormal, Layer_Normal); /* -hdf- June 98 */
return;
}
else if ((Blend_Map->Type == NORMAL_TYPE) && (Tnormal->Type != AVERAGE_PATTERN))
{
/* NK 19 Nov 1999 added Warp_EPoint */
Warp_EPoint (TPoint, EPoint, (TPATTERN *)Tnormal);
value1 = Evaluate_TPat((TPATTERN *)Tnormal,TPoint,Intersection,ray,Thread);
Search_Blend_Map (value1,Blend_Map,&Prev,&Cur);
Warp_Normal(Layer_Normal,Layer_Normal, (TPATTERN *)Tnormal, Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
Assign_Vector(P1,Layer_Normal);
Warp_EPoint (TPoint, EPoint, (TPATTERN *)Tnormal);
Perturb_Normal(Layer_Normal,Cur->Vals.Tnormal,TPoint,Intersection,ray,Thread);
if (Prev != Cur)
{
Perturb_Normal(P1,Prev->Vals.Tnormal,TPoint,Intersection,ray,Thread);
value2 = (value1-Prev->value)/(Cur->value-Prev->value);
value1 = 1.0-value2;
VLinComb2(Layer_Normal,value1,P1,value2,Layer_Normal);
}
UnWarp_Normal(Layer_Normal,Layer_Normal,(TPATTERN *)Tnormal, Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
VNormalizeEq(Layer_Normal);
Assign_Vector(Intersection->PNormal, Layer_Normal); /* -hdf- June 98 */
return;
}
}
/* No normal_map. */
if (Tnormal->Type <= LAST_NORM_ONLY_PATTERN)
{
Warp_Normal(Layer_Normal,Layer_Normal, (TPATTERN *)Tnormal,
Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
Warp_EPoint (TPoint, EPoint, (TPATTERN *)Tnormal);
switch (Tnormal->Type)
{
case BITMAP_PATTERN: bump_map (TPoint, Tnormal, Layer_Normal); break;
case BUMPS_PATTERN: bumps (TPoint, Tnormal, Layer_Normal); break;
case DENTS_PATTERN: dents (TPoint, Tnormal, Layer_Normal, Thread); break;
case RIPPLES_PATTERN: ripples (TPoint, Tnormal, Layer_Normal, Thread); break;
case WAVES_PATTERN: waves (TPoint, Tnormal, Layer_Normal, Thread); break;
case WRINKLES_PATTERN: wrinkles (TPoint, Tnormal, Layer_Normal); break;
case QUILTED_PATTERN: quilted (TPoint, Tnormal, Layer_Normal); break;
case FACETS_PATTERN: facets (TPoint, Tnormal, Layer_Normal, Thread); break;
case AVERAGE_PATTERN: Do_Average_Normals (TPoint, Tnormal, Layer_Normal, Intersection, ray, Thread); break;
default:
throw POV_EXCEPTION_STRING("Normal pattern not yet implemented.");
}
UnWarp_Normal(Layer_Normal,Layer_Normal, (TPATTERN *)Tnormal,
Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
}
else
{
Warp_Normal(Layer_Normal,Layer_Normal, (TPATTERN *)Tnormal,
Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
Amount=Tnormal->Amount * -5.0; /*fudge factor*/
Amount*=0.02/Tnormal->Delta; /* NK delta */
/* warp the center point first - this is the last warp */
Warp_EPoint(TPoint,EPoint,(TPATTERN *)Tnormal);
for(i=0; i<=3; i++)
{
VAddScaled(P1,TPoint,Tnormal->Delta,Pyramid_Vect[i]); /* NK delta */
value1 = Do_Slope_Map(Evaluate_TPat((TPATTERN *)Tnormal,P1,Intersection,ray,Thread),Blend_Map);
VAddScaledEq(Layer_Normal,value1*Amount,Pyramid_Vect[i]);
}
UnWarp_Normal(Layer_Normal,Layer_Normal,(TPATTERN *)Tnormal,
Test_Flag(Tnormal,DONT_SCALE_BUMPS_FLAG));
}
if ( Intersection )
Assign_Vector(Intersection->PNormal, Layer_Normal); /* -hdf- June 98 */
}
