void RmDir(const char *path)
{
if(IsFile(path) || IsLnk(path))
{
remove(path);
return;
}
char filePath[PATH_MAX];
if(IsDir(path))
{
DIR *dir;
struct dirent *ptr;
dir = opendir(path);
while(ptr = readdir(dir))
{
if(IsSpecial(ptr->d_name))
continue;
GetFilePath(path,ptr->d_name,filePath);
if(IsDir(filePath))
{
RmDir(filePath);
rmdir(filePath);
}
else if(IsFile(filePath) || IsLnk(filePath))
{
remove(filePath);
}
}
closedir(dir);
}
}
static void EscapeOBuf() {
int i, j;
unsigned char c;
if ((OBufSize > 0) && (OBuf[0] == STX) && (OBuf[OBufSize-1] == ETX)) {
bzero((void *) EscBuf, ESC_BUF_SIZE);
EscBufSize = 0;
EscBuf[0] = STX;
for (i=1,j=1; i<OBufSize-1; i++) {
c = OBuf[i];
if (IsSpecial(c)) {
EscBuf[j++] = ESC;
EscBuf[j++] = c + 0x40;
} else {
EscBuf[j++] = OBuf[i];
}
}
EscBuf[j++] = ETX;
for (i=0; i<j; i++) OBuf[i] = EscBuf[i];
EscBufSize = j;
OBufSize = j;
return;
}
fprintf(stderr,"libamp:Error:EscapeBuffer:Illegal size or not delimited by STX ETX\n");
}
/**
* Set the latitude given a value in the Planetographic coordinate system
*
* @param latitude The planetographic latitude to set ourselves to
* @param units The angular units latitude is in
*/
void Latitude::setPlanetographic(double latitude, Angle::Units units) {
if (m_equatorialRadius == NULL || m_polarRadius == NULL) {
IString msg = "Latitude [" + IString(latitude) + "] cannot be "
"converted to Planetocentic without the planetary radii, please use "
"the other Latitude constructor";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
Angle inputAngle(latitude, units);
if (inputAngle > Angle(90.0, Angle::Degrees) ||
inputAngle < Angle(-90.0, Angle::Degrees)) {
IString msg = "Latitudes outside of the -90/90 range cannot be converted "
"between Planetographic and Planetocentric";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
if(IsSpecial(latitude)) {
IString msg = "Invalid planetographic latitudes are not currently "
"supported";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
double ocentricLatitude = atan(tan(inputAngle.radians()) *
(*m_polarRadius / *m_equatorialRadius) *
(*m_polarRadius / *m_equatorialRadius));
// Sometimes the trig functions return the negative of the expected value at the pole.
if ((ocentricLatitude > 0) != (inputAngle.radians() > 0)) {
ocentricLatitude *= -1;
}
setAngle(ocentricLatitude, Angle::Radians);
}
template <class Output, class Ch, class Tr, class IsSpecial> inline
Output
in_quote(std::basic_istream<Ch, Tr> &i, Output out, IsSpecial is_special = IsSpecial(),
char quote_char='"', char escape_char='\\')
{
char c;
if (i.get(c)) {
*out++=c;
if (c==quote_char) { // quoted - end delimited by unescape quote
for (;;) {
if (!i.get(c))
goto fail;
if (c==quote_char)
break;
if (c==escape_char)
if (!i.get(c))
goto fail;
*out++=c;
}
} else { // unquoted - end delimited by an is_special char
while (i.get(c)) {
if (is_special(c)) {
i.unget();
break;
}
*out++=c;
}
}
} // else end of stream. shouldn't interpret as empty token but not throwing exception either. check status of i before you use.
return out;
fail:
throw std::runtime_error("end of file reached when parsing quoted string (in_quote)");
}
/**
* Get the current max. residual magnitude to become fully colored. This will return Null if it's
* undefined.
*/
double MosaicControlNetTool::maxMovementColorResidualMagnitude() const {
double result = Null;
if (!IsSpecial(m_residualMagnitude))
result = m_residualMagnitude;
return result;
}
/**
* Get the 2D (x/y) index position given an x/y dn value.
*
* @param x The x-dn value of the bin
* @param y The y-dn value of the bin
* @return The 2D (x/y) bin index position
*/
QPair<int, int> ScatterPlotData::binXYIndices(double x, double y) const {
QPair<int, int> indices(-1, -1);
if (m_counts->size() && m_counts->at(0).size()) {
double xBinPosition = m_xDnToBinStretch->Map(x);
double yBinPosition = m_yDnToBinStretch->Map(y);
if (!IsSpecial(xBinPosition) && !IsSpecial(yBinPosition)) {
int discreteXBin = qRound(xBinPosition);
int discreteYBin = qRound(yBinPosition);
if (discreteXBin >= 0 && discreteXBin < m_counts->at(0).size() &&
discreteYBin >= 0 && discreteYBin < m_counts->size()) {
indices = QPair<int, int>(discreteXBin, discreteYBin);
}
}
}
return indices;
}
template <class Ch, class Tr, class IsSpecial> inline
std::string
in_quote(std::basic_istream<Ch, Tr> &i, IsSpecial is_special = IsSpecial(),
char quote_char='"', char escape_char='\\')
{
// std::basic_stringstream<Ch,Tr> s;
std::vector<Ch> v;
in_quote(i, back_inserter(v)//std::ostreambuf_iterator<Ch,Tr>(s)
, is_special, quote_char, escape_char);
return std::string(v.begin(), v.end());
// return s.str();
}
int cCursesString::GetFlags(int index, int* flags, int* colors) {
char ch = GetChar(index);
*colors = 0;
if ( IsSpecial(index) ) {
switch (ch)
{
case ATTR_BOLD: {
*flags |= A_BOLD;
break;
}
case ATTR_COLOR: {
*colors = 1;
break;
}
case ATTR_RESET: {
*flags = ATTR_RESET;
break;
}
case ATTR_FIXED: {
/* dunno */
break;
}
case ATTR_REVERSE:
case ATTR_REVERSE2: {
*flags |= A_REVERSE;
break;
}
case ATTR_ITALIC: {
/* Dunno, ncurses doesnt support italic stuff */
break;
}
case ATTR_UNDERLINE2:
case ATTR_UNDERLINE: {
*flags |= A_UNDERLINE;
break;
}
default:
break;
}
}
return 0;
}
void Attribute::SetTransformValue (std::string const & value)
{
std::string::const_iterator current =
std::find_if (value.begin (), value.end (), IsSpecial ());
if (current == value.end ())
{
_value = value;
return;
}
std::string::const_iterator firstNotAdded = value.begin ();
do
{
Assert (current != value.end ());
_value.append (firstNotAdded, current);
_value.append (XML::TransformSpecial (*current));
++current;
firstNotAdded = current;
current = std::find_if (current, value.end (), IsSpecial ());
} while (current != value.end ());
_value.append (firstNotAdded, value.end ());
}
/**
* Takes a double pixel value and returns the name of the pixel type as a
* string
*
* @param d Pixel value
*
* @return string The name of the pixel type
*/
string Pixel::ToString(double d) {
if(IsSpecial(d)) {
if(IsNull(d)) return string("Null");
else if(IsLrs(d)) return string("Lrs");
else if(IsHrs(d)) return string("Hrs");
else if(IsHis(d)) return string("His");
else if(IsLis(d)) return string("Lis");
else return string("Invalid");
}
QString result;
return result.setNum(d).toStdString();
}
wxString SFTPAttribute::GetTypeAsString() const
{
if ( IsSpecial() ) {
return "Special";
} else if ( IsFolder() ) {
return "Folder";
} else if ( IsSymlink() ) {
return "Symlink";
} else if ( IsFile() ) {
return "File";
} else {
return "Unknown";
}
}
/**
* We're overriding this method in order to do -90/90 degree checking
*
* @param angle The numeric value of the angle
* @param units The units angle is in (radians or degrees typically)
*/
void Latitude::setAngle(double angle, const Angle::Units &units) {
// Check for passing 90 degrees if that error checking is on
if (!IsSpecial(angle) && (m_errors & AllowPastPole) != AllowPastPole) {
Angle tmpAngle(angle, units);
if(tmpAngle > Angle(90, Angle::Degrees) ||
tmpAngle < Angle(-90, Angle::Degrees)) {
IString msg = "Latitudes past 90 degrees are not valid. The latitude "
"[" + IString(tmpAngle.degrees()) + " degrees] is not allowed";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
}
Angle::setAngle(angle, units);
}
short
RasterBuffer::GetInterpolated(unsigned lx, unsigned ly,
unsigned ix, unsigned iy) const
{
assert(IsDefined());
assert(lx < GetWidth());
assert(ly < GetHeight());
assert(ix < 0x100);
assert(iy < 0x100);
// perform piecewise linear interpolation
const unsigned int dx = (lx == GetWidth() - 1) ? 0 : 1;
const unsigned int dy = (ly == GetHeight() - 1) ? 0 : GetWidth();
const short *tm = GetDataAt(lx, ly);
if (IsSpecial(*tm) || IsSpecial(tm[dx]) ||
IsSpecial(tm[dy]) || IsSpecial(tm[dx + dy]))
return *tm;
unsigned kx = 0x100 - ix;
unsigned ky = 0x100 - iy;
return (*tm * kx * ky + tm[dx] * ix * ky + tm[dy] * kx * iy + tm[dx + dy] * ix * iy) >> 16;
}
// -----------------------------------------------------------------------------
// TSTSCharacterSetConverter::EscapedUnicodeToPrintableL
// Converts string from escaped unicode to printable string
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
HBufC8* TSTSCharacterSetConverter::EscapedUnicodeToPrintableLC(
const TDesC& aValue) const
{
TInt valueLength = aValue.Length();
// returned value can never be longer than the original (it can be shorter)
HBufC8* value = HBufC8::NewL(valueLength);
CleanupStack::PushL(value);
TPtr8 valueDes = value->Des();
TLex lexer(aValue);
while (!lexer.Eos())
{
TChar currentChar = lexer.Get();
if (currentChar == '\\')
{
// we are escaping
if (lexer.Eos())
{
User::Leave(KSTSErrInvalidCAName);
}
lexer.Mark();
currentChar = lexer.Get();
if (!IsSpecial(currentChar))
{
if (lexer.Eos())
{
User::Leave(KSTSErrInvalidCAName);
}
lexer.Get();
TLex hexPair(lexer.MarkedToken());
TUint hexChar;
User::LeaveIfError(hexPair.Val(hexChar, EHex));
currentChar = hexChar;
}
}
if (IsPrintable(currentChar))
{
valueDes.Append(currentChar);
}
else
{
User::Leave(KSTSErrInvalidCharactersInCAName);
}
}
return value;
}
void WLex::PutValue(String &str)
{
if(!IsEol())
{
putc(Delimiter(), m_File);
}
else
{
m_bEOL = false;
}
for(int i = 0; i < int(str.length()); ++i)
{
if(IsSpecial(str[i]))
{
putc('\\', m_File);
}
putc(str[i], m_File);
}
}
void
RasterRenderer::GenerateUnshadedImage(unsigned height_scale,
const unsigned contour_height_scale)
{
const auto *src = height_matrix.GetData();
const RawColor *oColorBuf = color_table + 64 * 256;
RawColor *dest = image->GetTopRow();
for (unsigned y = height_matrix.GetHeight(); y > 0; --y) {
RawColor *p = dest;
dest = image->GetNextRow(dest);
unsigned contour_row_base = ContourInterval(*src, contour_height_scale);
unsigned char *contour_this_column_base = contour_column_base;
for (unsigned x = height_matrix.GetWidth(); x > 0; --x) {
const auto e = *src++;
if (gcc_likely(!e.IsSpecial())) {
unsigned h = std::max(0, (int)e.GetValue());
const unsigned contour_interval =
ContourInterval(h, contour_height_scale);
h = std::min(254u, h >> height_scale);
if (gcc_unlikely((contour_interval != contour_row_base)
|| (contour_interval != *contour_this_column_base))) {
*p++ = oColorBuf[(int)h - 64 * 256];
*contour_this_column_base = contour_row_base = contour_interval;
} else {
*p++ = oColorBuf[h];
}
} else if (e.IsWater()) {
// we're in the water, so look up the color for water
*p++ = oColorBuf[255];
} else {
/* outside the terrain file bounds: white background */
*p++ = RawColor(0xff, 0xff, 0xff);
}
contour_this_column_base++;
}
/**
* Called when the mouse moves over this widget
*
* @param event
*/
void VisualDisplay::mouseMoveEvent(QMouseEvent *event) {
double startX = width() / 2 - (p_boxWidth * (int)floor(p_boxSamps / 2) + (p_boxWidth / 2));
double startY = height() / 2 - (p_boxHeight * (int)floor(p_boxLines / 2) + (p_boxHeight / 2));
int x = (int)ceil((event->x() - startX) / p_boxWidth);
int y = (int)ceil((event->y() - startY) / p_boxHeight);
if(!p_set || x < 1 || y < 1 || x > p_boxSamps || y > p_boxLines) {
emit setSample("Sample: n/a");
emit setLine("Line: n/a");
emit setDn("DN: n/a");
}
else {
emit setSample(QString("Sample: %1").arg(p_ulSamp + x - 1));
emit setLine(QString("Line: %1").arg(p_ulLine + y - 1));
double dn = p_pixelData[y-1][x-1];
if(IsSpecial(dn))
emit setDn(QString("DN: %1").arg(PixelToString(dn)));
else
emit setDn(QString("DN: %1").arg(dn));
}
}
void iTime::setEt(double et) {
if(!IsSpecial(et))
p_et = et;
else
p_et = 0.0;
}
void iTime::operator +=(const double &secondsToAdd) {
if(!IsSpecial(secondsToAdd) && !IsSpecial(p_et) && (p_et != 0.0))
p_et += secondsToAdd;
}
/**
* Writes a floating-point value out to the next column in the current row
*
* @param item The value to be printed out
*/
void WriteTabular::Write(double item){
Column thisCol = p_cols[p_curCol];
if (thisCol.DataType() != Column::Real &&
thisCol.DataType() != Column::Pixel) {
std::string message = "Wrong data type for this Column";
throw Isis::iException::Message(Isis::iException::User,message,_FILEINFO_);
}
//Check for special pixels, if it's a pixel column
if (thisCol.DataType() == Column::Pixel && IsSpecial(item)) {
if (IsNullPixel(item)) {
Write("Null");
return;
}
if (IsHisPixel(item)) {
Write("His");
return;
}
if (IsHrsPixel(item)) {
Write("Hrs");
return;
}
if (IsLisPixel(item)) {
Write("Lis");
return;
}
if (IsLrsPixel(item)) {
Write("Lrs");
return;
}
}
iString thisItem(item);
if (thisCol.Alignment() == Column::Decimal) {
//Format and round the number
//First, split the number at the decimal point
iString tempString = thisItem;
iString intPart = tempString.Token(".");
//Make the fractional portion appear as such, so the iomanipulators
//handle it properly
if (tempString != "") {
tempString = "0." + tempString;
}
else tempString = "0.0";
//Put the fractional portion into a stringstream, and use
//stream manipulators to round it properly
std::stringstream b;
b << std::showpoint
<< std::setprecision(thisCol.Precision())
<< tempString.ToDouble();
//if the rounding causes a rollover (i.e. the decimal portion is greater
//than 0.95) increment the integer portion
if (iString(b.str()).ToDouble() >= 1) {
intPart = iString(intPart.ToInteger() + 1);
}
//Put it back into an iString, for easier manipulation
tempString = b.str();
tempString.Token(".");
//Add any zeros necessary to pad the number
while (tempString.size() < thisCol.Precision()) {
tempString += "0";
}
//Put the number back together, adding the decimal point in the right location
thisItem = intPart + "." + tempString;
}
std::stringstream tempStream;
tempStream.width(thisCol.Width());
tempStream.fill(' ');
if (thisCol.Alignment() == Column::Left) {
tempStream.setf(std::ios::left);
}
else tempStream.setf(std::ios::right);
tempStream << thisItem;
thisItem = tempStream.str();
if (p_curCol == 0) {
p_rows++;
}
//If the number is too wide for the column, replace with a string of stars
if (thisItem.length() > thisCol.Width()) {
thisItem = "*";
while (thisItem.length() < thisCol.Width()) {
thisItem += "*";
}
}
if (p_curCol < (p_cols.size()-1)) {
thisItem += p_delimiter;
p_curCol++;
}
else {
thisItem += "\n";
p_curCol = 0;
}
p_outfile << thisItem;
}
inline void out_quote(std::basic_ostream<Ch, Tr> &out, const C& data, IsSpecial is_special = IsSpecial(), char quote_char='"', char escape_char='\\') {
std::basic_stringstream<Ch, Tr> s;
s << data;
or_true_for_chars<IsSpecial> needs_quote(quote_char, escape_char, is_special);
typedef std::istreambuf_iterator<Ch, Tr> i_iter;
typedef std::ostream_iterator<Ch, Tr> o_iter;
i_iter i(s), end;
bool quote = (std::find_if (i, end, needs_quote) != end);
rewind(s);
if (quote) {
out << quote_char;
for (i_iter i(s); i!=end; ++i) {
Ch c=*i;
if (c == quote_char || c== escape_char)
out.put(escape_char);
out.put(c);
}
out << quote_char;
} else {
// std::copy(i_iter(s),end,o_iter(out));
/*
for (i_iter i(s);i!=end;++i)
out.put(*i);
*/
Ch c;
while (s.get(c))
out.put(c);
}
}
/**
* Paint the pixmap
*
*/
void VisualDisplay::paintPixmap() {
p_pixmap = QPixmap(p_boxSamps * p_boxWidth, p_boxLines * p_boxHeight);
p_pixmap.fill();
QPainter p(&p_pixmap);
QRect rect(0, 0, p_boxWidth, p_boxHeight);
int midX = p_pixmap.width() / 2 - ((p_boxWidth / 2) * (p_boxSamps % 2));
int midY = p_pixmap.height() / 2 - ((p_boxHeight / 2) * (p_boxLines % 2));
int x, y;
y = 0;
for(int i = 0; i < p_boxLines; i++) {
x = 0;
for(int j = 0; j < p_boxSamps; j++) {
double dn = p_pixelData[i][j];
QColor c;
if(p_showPixels || p_showDeviation) {
if(p_showDeviation) {
if(!IsSpecial(dn) && p_stats.TotalPixels() > 0 && p_stats.StandardDeviation() != 0) {
double diff;
if(dn < p_stats.Average()) {
diff = p_stats.Average() - dn;
diff /= p_stats.Average() - p_stats.Minimum();
}
else {
diff = dn - p_stats.Average();
diff /= p_stats.Maximum() - p_stats.Average();
}
int i = (int)(diff * 255.0);
c = QColor(i, 255 - i, 0);
}
else {
c = QColor(0, 0, 0);
}
}
else {
double visualValue = p_stretch.Map(dn);
c = QColor(visualValue, visualValue, visualValue);
}
}
p.save();
p.translate(x, y);
if(p_showText) {
p.drawRect(rect);
if (!IsSpecial(dn))
p.drawText(rect, Qt::AlignCenter, QString::number(dn));
else
p.drawText(rect, Qt::AlignCenter, PixelToString(dn));
}
else {
p.fillRect(rect, c);
}
p.restore();
x += p_boxWidth;
}
y += p_boxHeight;
}
p.setPen(QPen(Qt::red, 1));
p.save();
p.translate(midX, midY);
p.drawRect(rect);
p.restore();
update();
}
/**
* ScatterPlotDataConstructor
*
* @param xCube The x-axis cube
* @param xCubeBand The x-axis cube's band to get DN values from
* @param xBinCount The resolution of the x-axis
* @param yCube The y-axis cube
* @param yCubeBand The y-axis cube's band to get DN values from
* @param yBinCount The resolution of the y-axis
* @param sampleRange The sample range to gather the histogram from, this is
* the same for the x cube and y cube.
* @param lineRange The line range to gather the histogram from, this is
* the same for the x cube and y cube.
*/
ScatterPlotData::ScatterPlotData(
Cube *xCube, int xCubeBand, int xBinCount,
Cube *yCube, int yCubeBand, int yBinCount,
QwtInterval sampleRange, QwtInterval lineRange) : QwtRasterData(),
m_xDnToBinStretch(new Stretch), m_yDnToBinStretch(new Stretch),
m_counts(
new QVector< QVector<int> >(yBinCount, QVector<int>(xBinCount))),
m_alarmedBins(new QMap<int, bool>) {
int startLine = qRound(lineRange.minValue());
int endLine = qRound(lineRange.maxValue());
ASSERT(xCube->lineCount() == yCube->lineCount());
Histogram *xCubeHist = new Histogram(*xCube, xCubeBand, NULL,
sampleRange.minValue(), lineRange.minValue(),
sampleRange.maxValue(), lineRange.maxValue(),
xBinCount, true);
m_xCubeMin = xCubeHist->Minimum();
m_xCubeMax = xCubeHist->Maximum();
Histogram *yCubeHist = new Histogram(*yCube, yCubeBand, NULL,
sampleRange.minValue(), lineRange.minValue(),
sampleRange.maxValue(), lineRange.maxValue(),
yBinCount, true);
m_yCubeMin = yCubeHist->Minimum();
m_yCubeMax = yCubeHist->Maximum();
m_xDnToBinStretch->AddPair(m_xCubeMin, 0);
m_xDnToBinStretch->AddPair(m_xCubeMax, xBinCount - 1);
m_yDnToBinStretch->AddPair(m_yCubeMin, 0);
m_yDnToBinStretch->AddPair(m_yCubeMax, yBinCount - 1);
m_maxCount = 0;
Brick brick1((int)(sampleRange.maxValue() - sampleRange.minValue() + 1),
1, 1, xCube->pixelType());
Brick brick2((int)(sampleRange.maxValue() - sampleRange.minValue() + 1),
1, 1, yCube->pixelType());
ASSERT(xCube->sampleCount() == yCube->sampleCount());
ASSERT(brick1.size() == brick2.size());
for (int line = startLine; line <= endLine; line++) {
brick1.SetBasePosition(qRound(sampleRange.minValue()), line, xCubeBand);
xCube->read(brick1);
brick2.SetBasePosition(qRound(sampleRange.minValue()), line, yCubeBand);
yCube->read(brick2);
for (int i = 0; i < brick1.size(); i++) {
double xDn = brick1[i];
double yDn = brick2[i];
if (!IsSpecial(xDn) && !IsSpecial(yDn)) {
double x = m_xDnToBinStretch->Map(xDn);
double y = m_yDnToBinStretch->Map(yDn);
if (!IsSpecial(x) && !IsSpecial(y)) {
int roundedX = qRound(x);
int roundedY = qRound(y);
if (roundedX >= 0 && roundedX < xBinCount &&
roundedY >= 0 && roundedY < yBinCount) {
int value = (*m_counts)[roundedY][roundedX] + 1;
(*m_counts)[roundedY][roundedX] = value;
m_maxCount = qMax(m_maxCount, value);
}
}
}
}
}
setInterval(Qt::XAxis, QwtInterval(m_xCubeMin, m_xCubeMax));
setInterval(Qt::YAxis, QwtInterval(m_yCubeMin, m_yCubeMax));
setInterval(Qt::ZAxis, QwtInterval(0, m_maxCount));
}
