long double MoonPhase(long double jdt)
{
static long double d1, d2;
if (jdt > d2){
d1 = d2;
if (d1 == 0) d1 = MoonPhasePrevious(jdt, 0);
d2 = Squeeze(d1 + 30, 0);
}
return jdt - d1;
}
static int
compress_keccak (uint8_t *out, const uint8_t *blocks[], unsigned int blocks_to_comp)
{
spongeState sponge;
if (InitSponge (&sponge, KECCAK_RATE, KECCAK_CAPACITY))
return ERROR_KECCAK;
for (unsigned int i = 0; i < blocks_to_comp; i++) {
if (Absorb (&sponge, blocks[i], 8 * KECCAK_1600_BLOCK_SIZE))
return ERROR_KECCAK;
}
if (Squeeze (&sponge, out, 8 * KECCAK_1600_BLOCK_SIZE))
return ERROR_KECCAK;
return ERROR_NONE;
}
/**
Create the vtkStructuredGrid from the provided workspace
@param progressUpdating: Reporting object to pass progress information up the
stack.
@return fully constructed vtkDataSet.
*/
vtkSmartPointer<vtkDataSet>
vtkMDLineFactory::create(ProgressAction &progressUpdating) const {
auto product = tryDelegatingCreation<IMDEventWorkspace, 1>(m_workspace,
progressUpdating);
if (product != nullptr) {
return product;
} else {
g_log.warning() << "Factory " << this->getFactoryTypeName()
<< " is being used. You are viewing data with less than "
"three dimensions in the VSI. \n";
IMDEventWorkspace_sptr imdws =
doInitialize<IMDEventWorkspace, 1>(m_workspace);
// Acquire a scoped read-only lock to the workspace (prevent segfault from
// algos modifying ws)
Mantid::Kernel::ReadLock lock(*imdws);
const size_t nDims = imdws->getNumDims();
size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
/*
Write mask array with correct order for each internal dimension.
*/
auto masks = Mantid::Kernel::make_unique<bool[]>(nDims);
for (size_t i_dim = 0; i_dim < nDims; ++i_dim) {
bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
masks[i_dim] =
!bIntegrated; // TRUE for unmaksed, integrated dimensions are masked.
}
// Ensure destruction in any event.
boost::scoped_ptr<IMDIterator> it(
createIteratorWithNormalization(m_normalizationOption, imdws.get()));
// Create 2 points per box.
vtkNew<vtkPoints> points;
points->SetNumberOfPoints(it->getDataSize() * 2);
// One scalar per box
vtkNew<vtkFloatArray> signals;
signals->Allocate(it->getDataSize());
signals->SetName(vtkDataSetFactory::ScalarName.c_str());
signals->SetNumberOfComponents(1);
size_t nVertexes;
auto visualDataSet = vtkSmartPointer<vtkUnstructuredGrid>::New();
visualDataSet->Allocate(it->getDataSize());
vtkNew<vtkIdList> linePointList;
linePointList->SetNumberOfIds(2);
Mantid::API::CoordTransform const *transform = NULL;
if (m_useTransform) {
transform = imdws->getTransformToOriginal();
}
Mantid::coord_t out[1];
auto useBox = std::vector<bool>(it->getDataSize());
double progressFactor = 0.5 / double(it->getDataSize());
double progressOffset = 0.5;
size_t iBox = 0;
do {
progressUpdating.eventRaised(double(iBox) * progressFactor);
Mantid::signal_t signal_normalized = it->getNormalizedSignal();
if (std::isfinite(signal_normalized) &&
m_thresholdRange->inRange(signal_normalized)) {
useBox[iBox] = true;
signals->InsertNextValue(static_cast<float>(signal_normalized));
auto coords = std::unique_ptr<coord_t[]>(
it->getVertexesArray(nVertexes, nNonIntegrated, masks.get()));
// Iterate through all coordinates. Candidate for speed improvement.
for (size_t v = 0; v < nVertexes; ++v) {
coord_t *coord = coords.get() + v * 1;
size_t id = iBox * 2 + v;
if (m_useTransform) {
transform->apply(coord, out);
points->SetPoint(id, out[0], 0, 0);
} else {
points->SetPoint(id, coord[0], 0, 0);
}
}
} // valid number of vertexes returned
else {
useBox[iBox] = false;
}
++iBox;
} while (it->next());
for (size_t ii = 0; ii < it->getDataSize(); ++ii) {
progressUpdating.eventRaised((double(ii) * progressFactor) +
progressOffset);
if (useBox[ii] == true) {
vtkIdType pointIds = ii * 2;
linePointList->SetId(0, pointIds + 0); // xyx
linePointList->SetId(1, pointIds + 1); // dxyz
visualDataSet->InsertNextCell(VTK_LINE, linePointList.GetPointer());
} // valid number of vertexes returned
}
signals->Squeeze();
points->Squeeze();
visualDataSet->SetPoints(points.GetPointer());
visualDataSet->GetCellData()->SetScalars(signals.GetPointer());
visualDataSet->Squeeze();
// Hedge against empty data sets
if (visualDataSet->GetNumberOfPoints() <= 0) {
vtkNullUnstructuredGrid nullGrid;
visualDataSet = nullGrid.createNullData();
}
vtkSmartPointer<vtkDataSet> dataset = visualDataSet;
return dataset;
}
}
void CQDM_Edit::DrawMe(bool FastMode, bool ShowSelected, int NumBehindSection) //draws the digital part in initialized OpenGL window
//Show Selected highlights current sleceted voxel, Section view uses the currently selected axis and direction to show section, FadeBehindSelection optionally fades out the layers (for 2D view)
{
int Selected = GetCurSel();
if (!ShowSelected) Selected = -1; //don't draw the selected one...
if (FastMode && NumBehindSection != LAYERMAX) NumBehindSection = 0; //in fast mode don't draw faded out ones...
CVXC_Material* pMaterial;
bool IsVis;
int aS = Structure.GetArraySize();
int x, y, z, MatIndex;
int XMin=0, YMin=0, ZMin=0, XMax=LAYERMAX, YMax=LAYERMAX, ZMax=LAYERMAX;
if (ViewSection){
if (CurSecAxis == XAXIS){
if (CurSecFromNeg){ XMin = CurSecLayer; XMax = CurSecLayer+NumBehindSection;}
else {XMin = CurSecLayer-NumBehindSection; XMax = CurSecLayer;}
}
else if (CurSecAxis == YAXIS){
if (CurSecFromNeg){ YMin = CurSecLayer; YMax = CurSecLayer+NumBehindSection;}
else {YMin = CurSecLayer-NumBehindSection; YMax = CurSecLayer;}
}
else if (CurSecAxis == ZAXIS){
if (CurSecFromNeg){ ZMin = CurSecLayer; ZMax = CurSecLayer+NumBehindSection;}
else {ZMin = CurSecLayer-NumBehindSection; ZMax = CurSecLayer;}
}
}
Vec3D<> Center;
Vec3D<> Squeeze(Voxel.GetXSqueeze(), Voxel.GetYSqueeze(), Voxel.GetZSqueeze());
double Dim = GetLatticeDim();
Vec3D<> VoxEnv = GetLatDimEnv();
Vec3D<> WS(GetVXDim()*VoxEnv.x, GetVYDim()*VoxEnv.y, GetVZDim()*VoxEnv.z);
int NumCellAround = 0;
if (ViewTiled) NumCellAround = 1;
for (int ix=-NumCellAround; ix<=NumCellAround; ix++){ //for showing repeated unit cells
for (int jy=-NumCellAround; jy<=NumCellAround; jy++){
for (int kz=-NumCellAround; kz<=NumCellAround; kz++){
if(ViewSection){ //don't draw ones that aren't in current plane section
if (CurSecAxis == XAXIS && ix != 0) continue;
else if (CurSecAxis == YAXIS && jy != 0) continue;
else if (CurSecAxis == ZAXIS && kz != 0) continue;
}
glPushMatrix();
glTranslated(ix*WS.x, jy*WS.y, kz*WS.z);
for (int i = 0; i<aS; i++){ //go through all the voxels...
GetXYZNom(&x, &y, &z, i);
if (ViewSection && (x<XMin || x>XMax || y<YMin || y>YMax || z<ZMin || z>ZMax)) continue; //jump ship here if we're outside of the section view:
MatIndex = Structure[i];
if (MatIndex <= 0) continue; //don't draw if nothing there
if (FastMode){ //disable picking, show selected, and resolving composite materials
glColor3f(Palette[MatIndex].GetRedf(), Palette[MatIndex].GetGreenf(), Palette[MatIndex].GetBluef());
}
else { //NOT fastmode: enable picking, show selected, and resolve composite materials
glLoadName(i); //to enable picking
bool IsVis;
pMaterial = GetLeafMat(i, &IsVis);
if (pMaterial == NULL || !IsVis) continue;
if (pMaterial->GetAlphai() == 0) continue;
double FadeOut = 0.0;
if (ViewSection && NumBehindSection != LAYERMAX){ //if there's fading out to be done...
if (CurSecAxis == XAXIS) FadeOut = abs((double)(x - CurSecLayer))/(NumBehindSection+1);
else if (CurSecAxis == YAXIS) FadeOut = abs((double)(y - CurSecLayer))/(NumBehindSection+1);
else if (CurSecAxis == ZAXIS) FadeOut = abs((double)(z - CurSecLayer))/(NumBehindSection+1);
}
SetCurGLColor(pMaterial, i==Selected, FadeOut);
}
GetXYZ(&Center, i);
glPushMatrix();
glTranslated(Center.x, Center.y, Center.z);
glScaled(Dim*Squeeze.x, Dim*Squeeze.y, Dim*Squeeze.z);
switch (Voxel.GetVoxName()){
case VS_SPHERE: CGL_Utils::DrawSphereFace(); break;
case VS_BOX: CGL_Utils::DrawCubeFace(); break;
case VS_CYLINDER: CGL_Utils::DrawCylFace(); break;
default: break;
}
glPopMatrix();
}
if (!FastMode && Voxel.GetVoxName() != VS_SPHERE){ //no lines in fast mode or for spheres!
glDisable(GL_LIGHTING);
glLineWidth(1.0);
for (int i = 0; i<aS; i++){ //go through all the voxels...
GetXYZNom(&x, &y, &z, i);
if (ViewSection && (x<XMin || x>XMax || y<YMin || y>YMax || z<ZMin || z>ZMax)) continue; //jump ship here if we're outside of the section view:
if (Structure[i] <= 0) continue; //don't draw if nothing there
glColor3f(0, 0, 0);
GetXYZ(&Center, i);
glPushMatrix();
glTranslated(Center.x, Center.y, Center.z);
glScaled(Dim*Squeeze.x, Dim*Squeeze.y, Dim*Squeeze.z);
switch (Voxel.GetVoxName()){
case VS_BOX: CGL_Utils::DrawCubeEdge(); break;
case VS_CYLINDER: CGL_Utils::DrawCylEdge(); break;
default: break;
}
glPopMatrix();
}
glEnable(GL_LIGHTING);
}
glPopMatrix();
}
}
}
//if (!ViewSection){//if not in section mode, draw it all!
// //if(FastMode)
// DrawFast(Selctd, FastMode);
// //else Draw(Selctd);
//}
//else { //otherwise draw the appropriate section view
// switch (CurSecAxis){
// case ZAXIS: DrawSecZ(CurSecLayer, NumBehindSection, CurSecFromNeg, Selctd); break;
// case YAXIS: DrawSecY(CurSecLayer, NumBehindSection, CurSecFromNeg, Selctd); break;
// case XAXIS: DrawSecX(CurSecLayer, NumBehindSection, CurSecFromNeg, Selctd); break;
// }
//}
}
int main()
{
UINT32 x = 0;
int i;
{
UINT32 state[50];
const UINT32 imageOfAllZero[50] = {
0xD33D89FB, 0xC4B60CAD, 0x2FAD58B0, 0x88AE581B, 0xF4262C1A,
0x8A53D3EF, 0x77B4B09B, 0xE0147822, 0x10A38DCF, 0xB6305181,
0xF723F2BE, 0xF9C67B78, 0x4EB02ABA, 0x8FCCC118, 0x2DC2E52E,
0xA3B29275, 0x342F5536, 0xE4DD320A, 0x45C7C3EA, 0x493D8BE4,
0x9C1717E7, 0xF3E75194, 0x12A23D11, 0xEDD52441, 0x13E6DBFF,
0x8C61BB03, 0x945B1B82, 0x1E4A11A5, 0x1C3453E7, 0x0D730C1B,
0x3B9C1D29, 0x0C534AF4, 0xA6EC29CC, 0x4FFDAA4D, 0x96C7DAA5,
0x45487850, 0x4ECFBC29, 0xE630383B, 0x26806B48, 0xA7EB2B5A,
0x62D02426, 0x8265F750, 0x49D20B1A, 0x20E4D82C, 0x6F72B2B8,
0x1C45D049, 0xFEA9F415, 0x4D0E74C7, 0x8DFDEA09, 0xFCF72ED2 };
// Test 1 (all-zero state through Keccak-f[1600])
memset(state, 0, 50*sizeof(UINT32));
KeccakPermutation((unsigned char*)state);
for(i=0; i<50; i++)
if (state[i] != imageOfAllZero[i])
for( ; ; ) {
// Kaccek (aka other algo)
x++;
}
// For benchmarking
{
#ifdef ProvideFast1024
KeccakAbsorb1024bits((unsigned char*)state, (unsigned char*)imageOfAllZero);
#else
KeccakAbsorb((unsigned char*)state, (unsigned char*)imageOfAllZero, 16);
#endif
}
}
{
hashState state;
const UINT8 Msg29[4] = { 0x53, 0x58, 0x7B, 0xC8 };
const UINT8 Msg29_out[160] = {
0xDE, 0xEB, 0xFB, 0x5F, 0xBC, 0x67, 0x14, 0x3A, 0x70, 0xF5, 0xEE, 0x51, 0x8F, 0x3C, 0xE2, 0x0A,
0x70, 0x2A, 0x3C, 0x25, 0x0C, 0x22, 0xD9, 0x39, 0xD7, 0xEE, 0xF5, 0x98, 0xA3, 0x9C, 0xA5, 0xC5,
0x37, 0x41, 0xB6, 0xF5, 0x7B, 0x58, 0x40, 0xAD, 0xD2, 0x8E, 0xF6, 0x14, 0x0A, 0xAD, 0x9D, 0x4C,
0x2B, 0x8E, 0xCC, 0x6A, 0x89, 0xFC, 0x5E, 0xFE, 0x73, 0x1F, 0x5E, 0x69, 0x7B, 0x83, 0xB8, 0x1C,
0x27, 0xED, 0xE0, 0xD2, 0x26, 0xBB, 0x30, 0xDE, 0x0A, 0x93, 0xF5, 0xCE, 0xDB, 0xC1, 0x6E, 0x32,
0xBA, 0x9D, 0x6B, 0x10, 0x48, 0x8A, 0x5A, 0x0E, 0x55, 0x5C, 0xB2, 0x96, 0x9F, 0x51, 0xE5, 0x8D,
0x46, 0xF0, 0x03, 0xF5, 0x0F, 0x9D, 0x84, 0x5A, 0xAF, 0x43, 0x07, 0x66, 0x76, 0x23, 0x82, 0xAD,
0xFD, 0x9B, 0x4C, 0xF0, 0x59, 0x16, 0xDF, 0xD6, 0x5C, 0x8A, 0x8C, 0xFC, 0xDE, 0xC5, 0xD0, 0x45,
0x34, 0x07, 0x38, 0x7D, 0xBC, 0xF3, 0xA7, 0x44, 0x26, 0x8E, 0x85, 0xB3, 0x5B, 0x50, 0x0E, 0xDD,
0x1E, 0xD5, 0x09, 0x01, 0x55, 0xA6, 0x35, 0xBF, 0xA4, 0x6A, 0xC2, 0x4D, 0xA7, 0x98, 0xE8, 0x24 };
UINT8 output[160];
// Test 2 (message of length 29 from ShortMsgKAT_0.txt)
Init(&state, 0);
Update(&state, Msg29, 29);
Final(&state, 0);
Squeeze(&state, output, 160*8);
for(i=0; i<160; i++)
if (output[i] != Msg29_out[i])
for( ; ; ) {
// Kaccek (aka other algo)
x++;
}
}
for ( ; ; ) ;
}
void keccak128(const unsigned char* in, const unsigned long long inlen, unsigned char *out) {
spongeState state;
InitSponge(&state, 1344, 256);
Absorb(&state, in, inlen*8);
Squeeze(&state, out, 128);
}
long double MoonPhaseNext(long double jdt, long double phase)
{
return Squeeze(jdt - 29.6 * fmod360(MoonPhaseGet(jdt) - phase) / 360 + 30, phase);
}
long double MoonPhasePrevious(long double jdt, long double phase)
{
return Squeeze(jdt - 29.6 * fmod360(MoonPhaseGet(jdt) - phase) / 360 + 1, phase);
}
/**
* Put a window back where it should be if we don't (any longer) control
* it and reparent it back up to the root. This leaves it where it was
* before we started (well, adjusted by any moves we've made to it
* since), and placed so that if we restart and take it back over, it'll
* wind up right where it is now, so restarting doesn't shift windows all
* over the place.
*/
void
RestoreWinConfig(TwmWindow *tmp)
{
int gravx, gravy;
int newx, newy;
// Things adjusting by the border have to move our border size, but
// subtract away from that the old border we're restoring.
const int borders = tmp->frame_bw + tmp->frame_bw3D - tmp->old_bw;
// If this window is "unmapped" by moving it way offscreen, and is in
// that state, move it back onto the window.
if(tmp->UnmapByMovingFarAway && !visible(tmp)) {
XMoveWindow(dpy, tmp->frame, tmp->frame_x, tmp->frame_y);
}
// If it's squeezed, unsqueeze it.
if(tmp->squeezed) {
Squeeze(tmp);
}
// This is apparently our standard "is this window still around?"
// idiom.
if(XGetGeometry(dpy, tmp->w, &JunkRoot, &JunkX, &JunkY,
&JunkWidth, &JunkHeight, &JunkBW, &JunkDepth) == 0) {
// Well, give up...
return;
}
// Get gravity bits to know how to move stuff around when we take
// away the decorations.
GetGravityOffsets(tmp, &gravx, &gravy);
// We want to move the window to where it should be "outside" of our
// frame. This varies depending on the window gravity detail, and we
// have to account for that, since on re-startup we'll be doing it to
// resposition it after we re-wrap it.
//
// e.g., in simple "NorthWest" gravity, we just made the frame start
// where the window did, and shifted the app window right (by the
// border width) and down (by the border width + titlebar). However,
// "SouthEast" gravity means the bottom right of the frame is where
// the windows' was, and the window itself shifted left/up by the
// border. Compare e.g. an xterm with -geometry "+0+0" with one
// using "-0-0" as an easy trick to make windows with different
// geoms.
newx = tmp->frame_x;
newy = tmp->frame_y;
// So, first consider the north/south gravity. If gravity is North,
// we put the top of the frame where the window was and shifted
// everything inside down, so the top of the frame now is where the
// window should be put. With South-y gravity, the window should
// wind up at the bottom of the frame, which means we need to shift
// it down by the titlebar height, plus twice the border width. But
// if the vertical gravity is neutral, then the window needs to wind
// up staying right where it is, because we built the frame around it
// without moving it.
//
// Previous code here (and code elsewhere) expressed this calculation
// by the rather confusing idiom ((gravy + 1) * border_width), which
// gives the right answer, but is confusing as hell...
if(gravy < 0) {
// North; where the frame starts (already set)
}
else if(gravy > 0) {
// South; shift down title + 2*border
newy += tmp->title_height + 2 * borders;
}
else {
// Neutral; down by the titlebar + border.
newy += tmp->title_height + borders;
}
// Now east/west. West means align with the frame start, east means
// align with the frame right edge, neutral means where it already
// is.
if(gravx < 0) {
// West; it's already correct
}
else if(gravx > 0) {
// East; shift over by 2*border
newx += 2 * borders;
}
else {
// Neutral; over by the left border
newx += borders;
}
// If it's in a WindowBox, reparent the frame back up to our real root
if(tmp->winbox && tmp->winbox->twmwin && tmp->frame) {
int xbox, ybox;
unsigned int j_bw;
// XXX This isn't right, right? This will give coords relative
// to the window box, but we're using them relative to the real
// screen root?
if(XGetGeometry(dpy, tmp->frame, &JunkRoot, &xbox, &ybox,
&JunkWidth, &JunkHeight, &j_bw, &JunkDepth)) {
ReparentWindow(dpy, tmp, WinWin, Scr->Root, xbox, ybox);
}
}
// Restore the original window border if there were one
if(tmp->old_bw) {
XSetWindowBorderWidth(dpy, tmp->w, tmp->old_bw);
}
// Reparent and move back to where it otter be
XReparentWindow(dpy, tmp->w, Scr->Root, newx, newy);
// If it came with a pre-made icon window, hide it
if(tmp->wmhints->flags & IconWindowHint) {
XUnmapWindow(dpy, tmp->wmhints->icon_window);
}
// Done
return;
}
/**
Create the vtkStructuredGrid from the provided workspace
@param progressUpdating: Reporting object to pass progress information up the
stack.
@return fully constructed vtkDataSet.
*/
vtkSmartPointer<vtkDataSet>
vtkMDHistoLineFactory::create(ProgressAction &progressUpdating) const {
auto product =
tryDelegatingCreation<MDHistoWorkspace, 1>(m_workspace, progressUpdating);
if (product != nullptr) {
return product;
} else {
g_log.warning() << "Factory " << this->getFactoryTypeName()
<< " is being used. You are viewing data with less than "
"three dimensions in the VSI. \n";
Mantid::Kernel::ReadLock lock(*m_workspace);
const int nBinsX =
static_cast<int>(m_workspace->getXDimension()->getNBins());
const coord_t minX = m_workspace->getXDimension()->getMinimum();
coord_t incrementX = m_workspace->getXDimension()->getBinWidth();
const int imageSize = nBinsX;
vtkNew<vtkPoints> points;
points->Allocate(static_cast<int>(imageSize));
vtkNew<vtkFloatArray> signal;
signal->Allocate(imageSize);
signal->SetName(vtkDataSetFactory::ScalarName.c_str());
signal->SetNumberOfComponents(1);
UnstructuredPoint unstructPoint;
const int nPointsX = nBinsX;
Column column(nPointsX);
NullCoordTransform transform;
// Mantid::API::CoordTransform* transform =
// m_workspace->getTransformFromOriginal();
Mantid::coord_t in[3];
Mantid::coord_t out[3];
double progressFactor = 0.5 / double(nBinsX);
double progressOffset = 0.5;
// Loop through dimensions
for (int i = 0; i < nPointsX; i++) {
progressUpdating.eventRaised(progressFactor * double(i));
in[0] = minX +
static_cast<coord_t>(i) * incrementX; // Calculate increment in x;
float signalScalar =
static_cast<float>(m_workspace->getSignalNormalizedAt(i));
if (!std::isfinite(signalScalar)) {
// Flagged so that topological and scalar data is not applied.
unstructPoint.isSparse = true;
} else {
if (i < (nBinsX - 1)) {
signal->InsertNextValue(static_cast<float>(signalScalar));
}
unstructPoint.isSparse = false;
}
transform.apply(in, out);
unstructPoint.pointId = points->InsertNextPoint(out);
column[i] = unstructPoint;
}
points->Squeeze();
signal->Squeeze();
auto visualDataSet = vtkSmartPointer<vtkUnstructuredGrid>::New();
visualDataSet->Allocate(imageSize);
visualDataSet->SetPoints(points.GetPointer());
visualDataSet->GetCellData()->SetScalars(signal.GetPointer());
for (int i = 0; i < nBinsX - 1; i++) {
progressUpdating.eventRaised((progressFactor * double(i)) +
progressOffset);
// Only create topologies for those cells which are not sparse.
if (!column[i].isSparse) {
vtkLine *line = vtkLine::New();
line->GetPointIds()->SetId(0, column[i].pointId);
line->GetPointIds()->SetId(1, column[i + 1].pointId);
visualDataSet->InsertNextCell(VTK_LINE, line->GetPointIds());
}
}
visualDataSet->Squeeze();
// Hedge against empty data sets
if (visualDataSet->GetNumberOfPoints() <= 0) {
vtkNullUnstructuredGrid nullGrid;
visualDataSet = nullGrid.createNullData();
}
vtkSmartPointer<vtkDataSet> dataset = visualDataSet;
return dataset;
}
}
