void
Dynamics::initOrientations(double kbT)
{
orientationData.resize(Sim->particles.size());
//std::sqrt(10.0/ (diameter * diameter))
dout << "Initialising the line orientations" << std::endl;
std::normal_distribution<> norm_dist;
for (size_t i = 0; i < Sim->particles.size(); ++i)
{
//Assign the new velocities
orientationData[i].orientation = Quaternion::identity();
Vector angVelCrossing;
for (size_t iDim = 0; iDim < NDIM; ++iDim)
angVelCrossing[iDim] = norm_dist(Sim->ranGenerator);
//Ensure the initial angular velocity is perpendicular to the
//director
double I = Sim->species[Sim->particles[i]]->getScalarMomentOfInertia(i);
if (std::isinf(I))
orientationData[i].angularVelocity = Vector(0,0,0);
else
{
orientationData[i].angularVelocity = Quaternion::initialDirector() ^ angVelCrossing;
orientationData[i].angularVelocity *= 0.5 * std::sqrt(kbT/I) * norm_dist(Sim->ranGenerator) / orientationData[i].angularVelocity.nrm();
}
}
}
vector<Alignment> Sampler::alignment_pair(size_t read_length, size_t fragment_length, double fragment_std_dev, double base_error, double indel_error) {
// simulate forward/reverse pair by first simulating a long read
normal_distribution<> norm_dist(fragment_length, fragment_std_dev);
int frag_len = round(norm_dist(rng));
auto fragment = alignment_with_error(frag_len, base_error, indel_error);
// then taking the ends
auto fragments = alignment_ends(fragment, read_length, read_length);
auto& aln1 = fragments.front();
auto& aln2 = fragments.back();
{ // name the alignments
string data;
aln1.SerializeToString(&data);
aln2.SerializeToString(&data);
int n;
#pragma omp critical(nonce)
n = nonce++;
data += std::to_string(n);
const string hash = sha1head(data, 16);
aln1.set_name(hash + "_1");
aln2.set_name(hash + "_2");
}
// set the appropriate flags for pairing
aln1.mutable_fragment_next()->set_name(aln2.name());
aln2.mutable_fragment_prev()->set_name(aln1.name());
// reverse complement the back fragment
fragments.back() = reverse_complement_alignment(fragments.back(),
(function<int64_t(int64_t)>) ([&](int64_t id) {
return (int64_t)node_length(id);
}));
return fragments;
}
void SpikingOutput::initialize_state(){
CImg<double>::iterator next_spk_time_it = next_spk_time->begin();
CImg<double>::iterator curr_ref_period_it = curr_ref_period->begin();
while(next_spk_time_it < next_spk_time->end()){ // For every spiking output
double first_firing_period;
// To initialize the state of each output, we set the last next_spk_time
// to the next firing period.
// Determine firing period in the "unwarped" time slot
if(isfinite(Spike_dist_shape)) // Select stochastic or deterministic spike times
first_firing_period = gam_dist(rand_gen);
else // Spike_dist_shape is infinite (not specified), so we do not use stochasticity
first_firing_period = 1; // 1Hz is the firing freq. in a "unwarped" time slot
*next_spk_time_it = first_firing_period * First_spk_delay; // Anticipate (if First_spk_delay < 1) or postpone (if First_spk_delay > 1) first spike time according to First_spk_delay
// Set refractory eriod for each neuron
if(Min_period_std_dev == 0.0) // If fixed refractory period:
*curr_ref_period_it = Min_period/1000.0;
else
*curr_ref_period_it = norm_dist(rand_gen);
next_spk_time_it++;
curr_ref_period_it++;
}
}
double normRand(double mean, double sigma)
{
// Create a Mersenne twister random number generator
// that is seeded once with #seconds since 1970
static boost::mt19937 rng(static_cast<unsigned> (std::time(0)));
// select Gaussian probability distribution
boost::normal_distribution<double> norm_dist(mean, sigma);
// bind random number generator to distribution, forming a function
boost::variate_generator<boost::mt19937&, boost::normal_distribution<double> > normal_sampler(rng, norm_dist);
// sample from the distribution
return normal_sampler();
}
int SampleNormal (double mean, double sigma, int seed)
{
// Create a Mersenne twister random number generator
// that is seeded once with #seconds since 1970
static mt19937 rng(static_cast<unsigned> (seed));
// select Gaussian probability distribution
normal_distribution<double> norm_dist(mean, sigma);
// bind random number generator to distribution, forming a function
variate_generator<mt19937&, normal_distribution<double> > normal_sampler(rng, norm_dist);
// sample from the distribution
return (int) normal_sampler();
}
static void Interp(const ImageData *image, DBL xcoor, DBL ycoor, RGBFTColour& colour, int *index, bool premul)
{
int iycoor, ixcoor, i;
int Corners_Index[4];
RGBFTColour Corner_Colour[4];
DBL Corner_Factors[4];
xcoor += 0.5;
ycoor += 0.5;
iycoor = (int)ycoor;
ixcoor = (int)xcoor;
no_interpolation(image, (DBL)ixcoor, (DBL)iycoor, Corner_Colour[0], &Corners_Index[0], premul);
no_interpolation(image, (DBL)ixcoor - 1, (DBL)iycoor, Corner_Colour[1], &Corners_Index[1], premul);
no_interpolation(image, (DBL)ixcoor, (DBL)iycoor - 1, Corner_Colour[2], &Corners_Index[2], premul);
no_interpolation(image, (DBL)ixcoor - 1, (DBL)iycoor - 1, Corner_Colour[3], &Corners_Index[3], premul);
if(image->Interpolation_Type == BILINEAR)
bilinear(Corner_Factors, xcoor, ycoor);
else if(image->Interpolation_Type == NORMALIZED_DIST)
norm_dist(Corner_Factors, xcoor, ycoor);
else
POV_ASSERT(false);
// We're using double precision for the colors here to avoid higher-than-1.0 results due to rounding errors,
// which would otherwise lead to stray dot artifacts when clamped to [0..1] range for a color_map or similar.
// (Note that strictly speaking we don't avoid such rounding errors, but rather make them small enough that
// subsequent rounding to single precision will take care of them.)
PreciseRGBFTColour temp_colour;
DBL temp_index = 0;
for (i = 0; i < 4; i ++)
{
temp_colour += PreciseRGBFTColour(Corner_Colour[i]) * Corner_Factors[i];
temp_index += Corners_Index[i] * Corner_Factors[i];
}
colour = RGBFTColour(temp_colour);
*index = (int)temp_index;
}
static void Interp(IMAGE *Image, DBL xcoor, DBL ycoor, COLOUR colour, int *index)
{
int iycoor, ixcoor, i;
int Corners_Index[4];
DBL Index_Crn[4];
COLOUR Corner_Colour[4];
DBL Red_Crn[4];
DBL Green_Crn[4];
DBL Blue_Crn[4];
DBL Filter_Crn[4];
DBL Transm_Crn[4];
DBL val1, val2, val3, val4, val5;
val1 = val2 = val3 = val4 = val5 = 0.0;
iycoor = (int)ycoor;
ixcoor = (int)xcoor;
for (i = 0; i < 4; i++)
{
Make_ColourA(Corner_Colour[i], 0.0, 0.0, 0.0, 0.0, 0.0);
}
/* OK, now that you have the corners, what are you going to do with them? */
if (Image->Interpolation_Type == BILINEAR)
{
no_interpolation(Image, (DBL)ixcoor + 1, (DBL)iycoor, Corner_Colour[0], &Corners_Index[0]);
no_interpolation(Image, (DBL)ixcoor, (DBL)iycoor, Corner_Colour[1], &Corners_Index[1]);
no_interpolation(Image, (DBL)ixcoor + 1, (DBL)iycoor - 1, Corner_Colour[2], &Corners_Index[2]);
no_interpolation(Image, (DBL)ixcoor, (DBL)iycoor - 1, Corner_Colour[3], &Corners_Index[3]);
for (i = 0; i < 4; i++)
{
Red_Crn[i] = Corner_Colour[i][pRED];
Green_Crn[i] = Corner_Colour[i][pGREEN];
Blue_Crn[i] = Corner_Colour[i][pBLUE];
Filter_Crn[i] = Corner_Colour[i][pFILTER];
Transm_Crn[i] = Corner_Colour[i][pTRANSM];
// Debug_Info("Crn %d = %lf %lf %lf\n",i,Red_Crn[i],Blue_Crn[i],Green_Crn[i]);
}
val1 = bilinear(Red_Crn, xcoor, ycoor);
val2 = bilinear(Green_Crn, xcoor, ycoor);
val3 = bilinear(Blue_Crn, xcoor, ycoor);
val4 = bilinear(Filter_Crn, xcoor, ycoor);
val5 = bilinear(Transm_Crn, xcoor, ycoor);
}
if (Image->Interpolation_Type == NORMALIZED_DIST)
{
no_interpolation(Image, (DBL)ixcoor, (DBL)iycoor - 1, Corner_Colour[0], &Corners_Index[0]);
no_interpolation(Image, (DBL)ixcoor + 1, (DBL)iycoor - 1, Corner_Colour[1], &Corners_Index[1]);
no_interpolation(Image, (DBL)ixcoor, (DBL)iycoor, Corner_Colour[2], &Corners_Index[2]);
no_interpolation(Image, (DBL)ixcoor + 1, (DBL)iycoor, Corner_Colour[3], &Corners_Index[3]);
for (i = 0; i < 4; i++)
{
Red_Crn[i] = Corner_Colour[i][pRED];
Green_Crn[i] = Corner_Colour[i][pGREEN];
Blue_Crn[i] = Corner_Colour[i][pBLUE];
Filter_Crn[i] = Corner_Colour[i][pFILTER];
Transm_Crn[i] = Corner_Colour[i][pTRANSM];
// Debug_Info("Crn %d = %lf %lf %lf\n",i,Red_Crn[i],Blue_Crn[i],Green_Crn[i]);
}
val1 = norm_dist(Red_Crn, xcoor, ycoor);
val2 = norm_dist(Green_Crn, xcoor, ycoor);
val3 = norm_dist(Blue_Crn, xcoor, ycoor);
val4 = norm_dist(Filter_Crn, xcoor, ycoor);
val5 = norm_dist(Transm_Crn, xcoor, ycoor);
}
colour[pRED] += val1;
colour[pGREEN] += val2;
colour[pBLUE] += val3;
colour[pFILTER] += val4;
colour[pTRANSM] += val5;
// Debug_Info("Final = %lf %lf %lf\n",val1,val2,val3);
// use bilinear for index try average later
for (i = 0; i < 4; i++)
{
Index_Crn[i] = (DBL)Corners_Index[i];
}
if (Image->Interpolation_Type == BILINEAR)
{
*index = (int)(bilinear(Index_Crn, xcoor, ycoor) + 0.5);
}
if (Image->Interpolation_Type == NORMALIZED_DIST)
{
*index = (int)(norm_dist(Index_Crn, xcoor, ycoor) + 0.5);
}
}
void SpikingOutput::renew_ref_period_val(CImg<double>::iterator curr_ref_period_it){
if(Min_period_std_dev > 0.0) // Add Gaussian white noise to the ref. period: Stochastic Min_period limit chosen
*curr_ref_period_it = norm_dist(rand_gen); // We only renew the refractory period time after the neuron fires. Since only one realization of the period is considered the distribution std. dev. does not need to be adjusted, as it is in DOI:10.1523/JNEUROSCI.3305-05.2005
// Else: no noise in freq limit.: fixed limit already set
}
int main(int argc, const char *argv[])
{
// parse arguments ///////////////////////////////////////////
// Declare the supported options.
po::options_description desc("Visualize data");
desc.add_options()
("help", "produce help message")
("width", po::value<double>()->required(), "Width ")
("height", po::value<double>()->required(), "Height ")
("dir", po::value<std::string>()->default_value("."), "Data directory")
;
po::positional_options_description pos;
pos.add("width", 1);
pos.add("height", 1);
pos.add("dir", 1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).positional(pos).run(), vm);
po::notify(vm);
double width = vm["width"].as<double>();
double height = vm["height"].as<double>();
std::string datadirectory = vm["dir"].as<std::string>();
// end of parse arguments ////////////////////////////////////
cv::Mat laser_pose, laser_ranges, scan_angles;
loadMat(laser_pose, datadirectory + "/laser_pose_all.bin");
loadMat(laser_ranges, datadirectory + "/laser_range_all.bin");
loadMat(scan_angles, datadirectory + "/scan_angles_all.bin");
cv::Mat laser_reflectance(laser_ranges.rows, laser_ranges.cols, CV_8U);
std::string floorplanfile = datadirectory + "/floorplan.png";
cv::Mat floorplan = cv::imread(floorplanfile, cv::IMREAD_GRAYSCALE);
if(! floorplan.data ) // Check for invalid input
{
std::cout << "Could not open or find the image" << std::endl ;
return -1;
}
cv::transpose(floorplan, floorplan);
cv::flip(floorplan, floorplan, 1);
cv::Vec2d size_bitmap(width, height);
cv::Vec2d margin(1, 1);
cv::Vec2d min_pt(- margin(0) - size_bitmap(0)/2, - margin(1) - size_bitmap(1)/2);
double max_range = 8;
cv::Vec2i gridsize(floorplan.size[0], floorplan.size[1]);
cv::Vec2d cellsize;
cv::divide(size_bitmap , gridsize, cellsize);
//std::cout << cellsize(0) << cellsize(1) << std::endl;
cv::Vec2i ncells;
cv::divide(min_pt, cellsize, ncells, -2);
OccupancyGrid2D<double, int> map(
min_pt(0),
min_pt(1),
cellsize(0),
cellsize(1),
ncells(0),
ncells(1));
// initialize map with occupancy with floorplan
for (int r = 0; r < ncells(0); ++r) {
for (int c = 0; c < ncells(1); ++c) {
int fp_r = r - margin(0) / cellsize(0);
int fp_c = c - margin(1) / cellsize(1);
if ((0 <= fp_r) && (fp_r < floorplan.rows)
&& (0 <= fp_c) && (fp_c < floorplan.cols)) {
map.og_.at<uint8_t>(r, c) = (floorplan.at<uint8_t>(fp_r, fp_c) > 127) ? map.FREE : map.OCCUPIED;
} else {
map.og_.at<uint8_t>(r, c) = map.OCCUPIED;
}
}
}
boost::mt19937 gen;
boost::normal_distribution<> norm_dist(1, NOISE_VARIANCE);
boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > norm_rand(gen, norm_dist);
for (int r = 0; r < scan_angles.rows; r++) {
double* pose = laser_pose.ptr<double>(r);
double* angles = scan_angles.ptr<double>(r);
double robot_angle = pose[2];
for (int c = 0; c < scan_angles.cols; c++) {
double total_angle = robot_angle + angles[c];
cv::Vec2d final_pos;
bool refl;
double range = map.ray_trace(pose[0], pose[1], total_angle, max_range, final_pos, refl);
range *= norm_rand();
laser_ranges.at<double>(r, c) = range;
laser_reflectance.at<uint8_t>(r, c) = (uint8_t) refl;
}
// draw input
cv::Mat visin;
cv::cvtColor(map.og_, visin, cv::COLOR_GRAY2BGR);
cv::Vec2d position(pose[0], pose[1]);
map.draw_lasers(visin, position, robot_angle, angles,
laser_ranges.ptr<double>(r),
laser_reflectance.ptr<uint8_t>(r),
scan_angles.cols,
CV_RGB(0, 255, 0));
cv::imshow("c", visin);
cv::waitKey(33);
}
saveMat(laser_ranges, "laser_range_all.bin");
saveMat(laser_reflectance, "laser_reflectance_all.bin");
}
/***************************
* void drawPhongSpan() *
* *
* This routine sets the *
* buffer values for each *
* span of pixels which *
* intersect the current *
* scanline. *
***************************/
void
drawPhongSpan(triple pt,float N[3],int dFlag)
{
int xpixel,hue,shade;
float colorindx, col;
triple hs;
/* negative values of xleft and xright have been pushed to machine0 */
xpixel = (int)xleft;
while (xpixel <= (int)xright) {
/* if z is closer to viewer than value in zBuffer continue */
if ( (zC < get_zBuffer(xpixel)) ) {
/* get the intensity for current point */
col = phong(pt,N);
put_cBuffer_axes(xpixel,'0');
put_zBuffer(xpixel,zC);
/* if mono (bw dsply) do black and white semi-random dithering */
if (mono || (dFlag == PSoption) || viewport->monoOn) {
if (get_random() < 100.0*exp((double)-1.3*(pi_sq*(col-.2)*(col-.2)))) {
put_cBuffer_indx(xpixel,black);
} else {
put_cBuffer_indx(xpixel,white);
}
} else {
/* glossy shading for one hue else dithered for many hues */
if (viewport->hueOffset == viewport->hueTop && !smoothError) {
colorindx = (float)(smoothConst+1) * col;
if (colorindx > (smoothConst+1)) colorindx = smoothConst+1;
put_cBuffer_indx(xpixel,XPixelColor((int)colorindx-1));
} else { /* probabalistic multi-hued dithering */
hs = norm_dist();
hue = (int)(intersectColor[0]+hs.x/20.0);
/* cannot dither out of color map range */
if (viewport->hueOffset < viewport->hueTop) {
if (hue < viewport->hueOffset)
hue = viewport->hueOffset;
else {
if (hue > viewport->hueTop)
hue = viewport->hueTop;
}
} else {
if (hue < viewport->hueTop)
hue = viewport->hueTop;
else {
if (hue > viewport->hueOffset)
hue = viewport->hueOffset;
}
}
col += hs.y/6.0; /* perturb intensity */
if (col > 1.0) put_cBuffer_indx(xpixel,white);
else {
if (col < 0.0) put_cBuffer_indx(xpixel,black);
else {
shade = (int)(col * 4.0);
put_cBuffer_indx(xpixel,XSolidColor(hue,shade));
}
}
}
}
} /* zC < zBuffer */
zC += dzdx;
if (viewport->hueOffset != viewport->hueTop || smoothError ||
viewport->monoOn)
intersectColor[0] += dcolor;
N[0] += dnorm.x; N[1] += dnorm.y; N[2] += dnorm.z;
pt.x += dpt.x; pt.y += dpt.y; pt.z += dpt.z;
xpixel++;
} /* while each pixel */
}
