public CrashData(Exception e, string Username)
{
this.Username = Username;
StackTrace trace = new StackTrace(e, true);
StackTraceData = trace.GetFrames().Select((sf) => {
return(new StackTraceData {
Line = sf.GetFileLineNumber(),
Column = sf.GetFileColumnNumber(),
Filename = sf.GetFileName(),
ClassName = sf.GetMethod().ReflectedType.FullName,
Method = sf.GetMethod().Name,
});
}).ToList();
ID = Guid.NewGuid().ToString();
ExceptionCode = e.HResult;
Source = e.Source;
StackTrace = e.StackTrace;
ExceptionName = e.GetType().Name;
Timestamp = LLTools.TimestampMS();
Date = DateTime.Now.ToLongDateString();
Time = DateTime.Now.ToLongTimeString();
XRITVersion = LibInfo.Version;
XRITCommit = LibInfo.CommitID;
if (e.InnerException != null)
{
InnerCrashData = new CrashData(e);
}
}
public GroupData()
{
SatelliteName = "Unknown";
RegionName = "Unknown";
SatelliteLongitude = 0f;
FrameTime = DateTime.Now;
Visible = new OrganizerData();
Infrared = new OrganizerData();
WaterVapour = new OrganizerData();
OtherData = new Dictionary <string, OrganizerData>();
IsFalseColorProcessed = false;
IsVisibleProcessed = false;
IsInfraredProcessed = false;
IsWaterVapourProcessed = false;
IsProcessed = false;
Failed = false;
RetryCount = 0;
CropImage = false;
Created = LLTools.Timestamp();
ColumnOffset = -1;
LineOffset = -1;
ColumnScalingFactor = 0f;
LineScalingFactor = 0f;
Code = DateTime.UtcNow.ToString();
HasNavigationData = false;
}
void SetConfigVars()
{
UIConsole.Log("Setting Configuration");
FileHandler.SkipEMWIN = !ProgConfig.EnableEMWIN;
FileHandler.SkipDCS = !ProgConfig.EnableDCS;
FileHandler.SkipWeatherData = !ProgConfig.EnableWeatherData;
if (ProgConfig.TemporaryFileFolder != null)
{
if (!LLTools.TestFolderAccess(ProgConfig.TemporaryFileFolder))
{
UIConsole.Error($"Cannot write file to Temporary Folder {ProgConfig.TemporaryFileFolder}");
throw new ApplicationException($"Cannot write file to Temporary Folder {ProgConfig.TemporaryFileFolder}");
}
FileHandler.TemporaryFileFolder = ProgConfig.TemporaryFileFolder;
}
if (ProgConfig.FinalFileFolder != null)
{
if (!LLTools.TestFolderAccess(ProgConfig.FinalFileFolder))
{
UIConsole.Error($"Cannot write file to Final Folder {ProgConfig.FinalFileFolder}");
throw new ApplicationException($"Cannot write file to Final Folder {ProgConfig.FinalFileFolder}");
}
FileHandler.FinalFileFolder = ProgConfig.FinalFileFolder;
}
ImageManager.EraseFiles = ProgConfig.EraseFilesAfterGeneratingFalseColor;
ImageManager.GenerateInfrared = ProgConfig.GenerateInfraredImages;
ImageManager.GenerateVisible = ProgConfig.GenerateVisibleImages;
ImageManager.GenerateWaterVapour = ProgConfig.GenerateWaterVapourImages;
ImageManager.MaxRetryCount = ProgConfig.MaxGenerateRetry;
ImageManager.UseNOAAFileFormat = ProgConfig.UseNOAAFormat;
ImageManager.GenerateLabels = ProgConfig.GenerateLabels;
ImageManager.GenerateLatLonOverlays = ProgConfig.GenerateLatLonOverlays;
ImageManager.GenerateMapOverlays = ProgConfig.GenerateMapOverlays;
ImageManager.GenerateLatLonLabel = ProgConfig.GenerateLatLonLabel;
Connector.ChannelDataServerName = ProgConfig.ChannelDataServerName;
Connector.StatisticsServerName = ProgConfig.StatisticsServerName;
Connector.ConstellationServerName = ProgConfig.ConstellationServerName;
Connector.ChannelDataServerPort = ProgConfig.ChannelDataServerPort;
Connector.StatisticsServerPort = ProgConfig.StatisticsServerPort;
Connector.ConstellationServerPort = ProgConfig.ConstellationServerPort;
if (LLTools.IsLinux)
{
SyslogClient.SysLogServerIp = ProgConfig.SysLogServer;
try {
SyslogClient.Send(ProgConfig.SysLogFacility, Level.Information, "Your syslog connection is working! OpenSatelliteProject is enabled to send logs.");
} catch (SocketException) {
UIConsole.Warn("Your syslog is not enabled to receive UDP request. Please refer to https://opensatelliteproject.github.io/OpenSatelliteProject/");
}
}
}
public void PutStatistic(DBStatistics statistics, bool autoTimestamp = true)
{
lock (statConn) {
if (autoTimestamp)
{
statistics.Timestamp = LLTools.TimestampMS();
}
statConn.Insert(statistics);
}
}
public static void Main(string[] args)
{
long startTime;
Image16 im = new Image16(21000, 21000);
Image16 im2 = new Image16(4096, 4096, 0x0);
UIConsole.Log("Benchmark Draw");
startTime = LLTools.TimestampMS();
im.DrawImage(im2, 1024, 1024, true);
UIConsole.Log($"Delta: {LLTools.TimestampMS() - startTime} ms");
UIConsole.Log("Benchmark Save PGM");
startTime = LLTools.TimestampMS();
im.SavePGM("test.pgm");
UIConsole.Log($"Delta: {LLTools.TimestampMS() - startTime} ms");
}
public void Refresh(Statistics_st data)
{
this.satelliteID = data.scid;
this.virtualChannelID = data.vcid;
this.packetNumber = data.packetNumber;
this.totalBits = data.frameBits;
this.viterbiErrors = data.vitErrors;
this.signalQuality = data.signalQuality;
this.syncCorrelation = data.syncCorrelation;
if (data.syncWord != null)
{
this.syncWord = string.Format("{0:X02}{1:X02}{2:X02}{3:X02}", data.syncWord[0], data.syncWord[1], data.syncWord[2], data.syncWord[3]);
}
else
{
this.syncWord = "00000000";
}
this.reedSolomon = data.rsErrors;
this.frameLock = data.frameLock > 0;
this.startTime = LLTools.UnixTimeStampToDateTime(data.startTime);
this.runningTime = DateTime.Now.Subtract(startTime);
}
private static string GenFilename(string satelliteName, string regionName, string imageName, int timestamp,
string origName = null)
{
if (UseNOAAFileFormat)
{
//gos15chnIR04rgnFDseg001res04dat130 18 06 19 190.lrit
origName = origName != null?Path.GetFileName(origName) : "";
var dt = LLTools.UnixTimeStampToDateTime(timestamp);
var year = dt.Year.ToString("0000");
var month = dt.Month.ToString("00");
var day = dt.Day.ToString("00");
var doy = dt.DayOfYear.ToString("000");
var hour = dt.Hour.ToString("00");
var minute = dt.Minute.ToString("00");
var second = dt.Second.ToString("00");
if (origName.Length == 48)
{
return($"{origName.Substring(0, 31)}{doy}{hour}{minute}{second}000.png");
}
else if (origName.StartsWith("IMG_DK"))
{
// Himawari
// IMG_DK01IR3_201705190350_002
return($"{origName.Substring(0, 12)}{year}{month}{day}{hour}{minute}_000.png");
}
else
{
// Return default
return($"{satelliteName}-{regionName}-{imageName}-{timestamp}.png");
}
}
else
{
return($"{satelliteName}-{regionName}-{imageName}-{timestamp}.png");
}
}
public static void Update(DBStatistics stats)
{
lock (statistics) {
stats.Timestamp = LLTools.TimestampMS();
if (stats.Timestamp == lastTimestamp)
{
stats.Timestamp++;
}
lastTimestamp = stats.Timestamp;
statistics.Add(stats);
if (LLTools.Timestamp() - lastCheck > checkInterval)
{
long startTime = LLTools.TimestampMS();
// Time to dump
foreach (var s in statistics)
{
ConfigurationManager.PutStatistics(s, false);
}
statistics.Clear();
lastCheck = LLTools.Timestamp();
}
}
}
public DemuxManager()
{
try {
demuxers = new Dictionary <int, Demuxer>();
productsReceived = new Dictionary <int, long>();
CRCFails = 0;
Bugs = 0;
Packets = 0;
LengthFails = 0;
FrameLoss = 0;
FrameJumps = 0;
recordMutex = new Mutex();
resetMutex = new Mutex();
if (RecordToFile)
{
fileName = string.Format("demuxdump-{0}.bin", LLTools.Timestamp());
UIConsole.Log(string.Format("Demux Dump filename: {0}", Path.GetFileName(fileName)));
fStream = File.OpenWrite(fileName);
}
} catch (Exception e) {
CrashReport.Report(e);
throw e;
}
}
public void Refresh()
{
ReceivedTime = LLTools.TimestampMS();
}
public MSDUInfo()
{
ReceivedTime = LLTools.TimestampMS();
}
public List <DHInfo> ListDir(string path)
{
var upperPath = "";
if (path.StartsWith("/"))
{
path = path.Substring(1);
}
if (path.Length > 0)
{
var tmp = !path.EndsWith("/") ? path + "/" : path;
upperPath = Path.GetDirectoryName(Path.GetDirectoryName(tmp));
}
var folder = Path.Combine(dataFolder, path);
if (folder.Contains("../"))
{
folder.Replace("../", "");
}
if (Directory.Exists(folder))
{
List <DHInfo> dhList = new List <DHInfo> ();
List <string> files = Directory.GetFiles(folder).Where(x => !x.EndsWith(".lrit")).OrderBy(a => a).ToList();
List <string> dirs = Directory.GetDirectories(folder).OrderBy(a => a).ToList();
if (path.Length > 0)
{
dhList.Add(new DHInfo {
IsFile = false,
Name = "..",
Path = upperPath,
LastModified = -1,
Size = -1
});
}
foreach (var file in dirs)
{
var name = Path.GetFileName(file);
var time = Directory.GetLastWriteTime(file);
dhList.Add(new DHInfo {
IsFile = false,
Name = name,
Path = Path.Combine(path, name),
LastModified = LLTools.DateTimeToTimestamp(time),
Size = -1
});
}
foreach (var file in files)
{
var name = Path.GetFileName(file);
var time = File.GetLastWriteTime(file);
var size = new System.IO.FileInfo(file).Length;
dhList.Add(new DHInfo {
IsFile = true,
Name = name,
Path = Path.Combine(path, name),
LastModified = LLTools.DateTimeToTimestamp(time),
Size = size
});
}
return(dhList);
}
else
{
return(null);
}
}
public void HandleAccess(HttpServer server, HttpRequestEventArgs e)
{
var req = e.Request;
var res = e.Response;
var upperPath = "";
var path = req.RawUrl.Split(new char[] { '?' }, 2)[0];
var relPath = path.Replace(BasePath, "").UrlDecode();
var download = req.QueryString["download"] != null;
if (relPath.StartsWith("/"))
{
relPath = relPath.Substring(1);
}
if (relPath.Length > 0)
{
var tmp = !relPath.EndsWith("/") ? relPath + "/" : relPath;
upperPath = Path.Combine(BasePath, Path.GetDirectoryName(Path.GetDirectoryName(tmp)));
}
var folder = Path.Combine(dataFolder, relPath);
if (folder.Contains("../"))
{
folder.Replace("../", "");
}
if (File.Exists(folder))
{
if (folder.Contains(".dcs") && !download)
{
// Assemble DCS Header table
List <DCSHeader> headers = DCSParser.parseDCS(folder);
string dcsList = "";
headers.ForEach(a => {
dcsList += String.Format(
"\t<tr>\n" +
"\t\t<th>{0}</th>\n" +
"\t\t<th>{1}</th>\n" +
"\t\t<th>{2}</th>\n" +
"\t\t<th>{3}</th>\n" +
"\t\t<th>{4}</th>\n" +
"\t\t<th>{5}</th>\n" +
"\t\t<th>{6}</th>\n" +
"\t\t<th>{7}</th>\n" +
"\t\t<th>{8}</th>\n" +
"\t</tr>\n",
a.Address,
a.DateTime.ToString(),
a.Status,
a.Signal,
a.FrequencyOffset,
a.ModIndexNormal,
a.DataQualNominal,
a.Channel,
a.SourceCode);
});
string listTable = "<table cellpadding=\"5\"cellspacing=\"0\">\n" +
"\t<tr>\n" +
"\t\t<th>Address</th>\n" +
"\t\t<th>Date / Time</th>\n" +
"\t\t<th>Status</th>\n" +
"\t\t<th>Signal</th>\n" +
"\t\t<th>Frequency Offset</th>\n" +
"\t\t<th>MIN</th>\n" +
"\t\t<th>DQN</th>\n" +
"\t\t<th>Channel</th>\n" +
"\t\t<th>Source Code</th>\n" +
"\t</tr>\n" +
"\t<tr><th colspan=\"9\"><hr></th></tr>\n" +
"{0}\n" +
"</table>\n";
listTable = string.Format(listTable, dcsList);
string output = string.Format(
"<html>\n" +
"\t<head>\n" +
"\t\t<title>OpenSatelliteProject - {0}</title>\n" +
"\t</head>\n" +
"\t<body>\n" +
"\t<h2>OpenSatelliteProject {0}</h2>\n" +
"\tDownload File: <a href=\"{2}\">{0}</a></BR>\n" +
"\t</BR>\n" +
"\t{1}\n" +
"\t</body>\n" +
"</html>", "/" + relPath.UrlDecode(), listTable, path + "?download=1");
res.StatusCode = (int)HttpStatusCode.OK;
res.WriteContent(Encoding.UTF8.GetBytes(output));
}
else
{
// Handle File load
try {
res.ContentType = Presets.GetMimeType(Path.GetExtension(folder));
res.StatusCode = (int)HttpStatusCode.OK;
res.SendChunked = true;
using (FileStream f = File.OpenRead(folder)) {
Stream o = res.OutputStream;
byte[] buffer = new byte[bufferSize];
long totalBytes = f.Length;
long readBytes = 0;
while (readBytes < totalBytes)
{
int rb = f.Read(buffer, 0, bufferSize);
readBytes += rb;
o.Write(buffer, 0, rb);
}
o.Close();
}
} catch (Exception ex) {
string output = string.Format("Error reading file: {0}", ex);
res.StatusCode = (int)HttpStatusCode.InternalServerError;
res.WriteContent(Encoding.UTF8.GetBytes(output));
}
}
}
else if (Directory.Exists(folder))
{
// Handle Directory Listing.
List <string> files = Directory.GetFiles(folder).Where(x => !x.EndsWith(".lrit")).OrderBy(a => a).ToList();
List <string> dirs = Directory.GetDirectories(folder).OrderBy(a => a).ToList();
string dirList = "";
string fileList = "";
if (upperPath.Length > 0)
{
dirList += string.Format("\t<tr>\n" +
"\t\t<td><img src=\"/static/folder.gif\"></td>\n" +
"\t\t<td><a href=\"{0}\">{1}</a></td>\n" +
"\t\t<td>{2}</td>\n" +
"\t\t<td>{3}</td>\n" +
"\t</tr>\n", upperPath, "..", "", "-");
}
foreach (var file in dirs)
{
var name = Path.GetFileName(file);
var time = Directory.GetLastWriteTime(file);
var url = Path.Combine(req.RawUrl, name.UrlEncode());
dirList += string.Format("\t<tr>\n" +
"\t\t<td><img src=\"/static/folder.gif\"></td>\n" +
"\t\t<td><a href=\"{0}\">{1}</a></td>\n" +
"\t\t<td>{2}</td>\n" +
"\t\t<td>{3}</td>\n" +
"\t</tr>\n", url, name, time, "-");
}
foreach (var file in files)
{
var name = Path.GetFileName(file);
var time = File.GetLastWriteTime(file);
var size = new System.IO.FileInfo(file).Length;
var url = Path.Combine(req.RawUrl, name.UrlEncode());
fileList += string.Format("\t<tr>\n" +
"\t\t<td><img src=\"/static/file.gif\"></td>\n" +
"\t\t<td><a href=\"{0}\">{1}</a></td>\n" +
"\t\t<td>{2}</td>\n" +
"\t\t<td>{3}</td>\n" +
"\t</tr>\n", url, name, time, LLTools.BytesToString(size));
}
string listTable = "<table cellpadding=\"5\"cellspacing=\"0\">\n" +
"\t<tr><th valign=\"top\"><img src=\"/static/blank.gif\"></th><th>Name</th><th>Last modified</th><th>Size</th></tr>\n" +
"\t<tr><th colspan=\"4\"><hr></th></tr>\n" +
"{0}\n" +
"{1}" +
"</table>\n";
listTable = string.Format(listTable, dirList, fileList);
string output = string.Format(
"<html>\n" +
"\t<head>\n" +
"\t\t<title>OpenSatelliteProject - {0}</title>\n" +
"\t</head>\n" +
"\t<body>\n" +
"\t<h2>OpenSatelliteProject {0}</h2>\n" +
"\t</BR>\n" +
"\t{1}\n" +
"\t</body>\n" +
"</html>", "/" + relPath.UrlDecode(), listTable);
res.StatusCode = (int)HttpStatusCode.OK;
res.WriteContent(Encoding.UTF8.GetBytes(output));
}
else
{
res.StatusCode = (int)HttpStatusCode.NotFound;
string res404 = "File not found";
res.WriteContent(Encoding.UTF8.GetBytes(res404));
}
}
void ThreadLoop()
{
UIConsole.Debug("MSDU Thread started");
while (running)
{
OpenSatelliteProject.GRB.MSDU msdu;
if (packets.TryDequeue(out msdu))
{
ProcessMSDU(msdu);
}
List <int> keys = msduCache.Keys.ToList();
keys.ForEach(k => {
var minfo = msduCache[k];
if (minfo.Expired)
{
UIConsole.Warn($"Product {k:X3} expired. Dumping...");
string msduFile = Path.Combine(FileHandler.TemporaryFileFolder, minfo.FileName);
string target = Path.Combine(FileHandler.TemporaryFileFolder, $"{k:X3}-{LLTools.TimestampMS()}-{Tools.RandomString(8)}");
File.Move(msduFile, target);
if (EnumHelpers.APID2Type(k) == PayloadType.Generic)
{
fileHandleManager.NewFile(new Tuple <string, object>(target, minfo.GenericHeader));
}
else
{
fileHandleManager.NewFile(new Tuple <string, object>(target, minfo.ImageHeader));
}
msduCache.Remove(k);
}
});
// Thread.Yield(); // This might be better
Thread.Sleep(2);
}
UIConsole.Debug("Channel Thread stopped");
}
void ProcessMSDU(OpenSatelliteProject.GRB.MSDU msdu)
{
try {
if (msdu.APID == 2047)
{
// Skip fill packet
return;
}
bool firstOrSinglePacket = msdu.Sequence == SequenceType.FIRST_SEGMENT || msdu.Sequence == SequenceType.SINGLE_DATA;
Packets++;
if (!msdu.Valid || !msdu.Full)
{
if (msdu.FrameLost)
{
UIConsole.Error($"Lost some frames on MSDU, the file will be corrupted. CRC Match: {msdu.Valid} - Size Match: {msdu.Full}");
}
else
{
UIConsole.Error($"Corrupted MSDU. CRC Match: {msdu.Valid} - Size Match: {msdu.Full}");
}
}
if (!msdu.Valid)
{
CRCFails++;
return;
}
var payloadType = EnumHelpers.APID2Type(msdu.APID);
if (msdu.Sequence == SequenceType.FIRST_SEGMENT || msdu.Sequence == SequenceType.SINGLE_DATA)
{
if (msduCache.ContainsKey(msdu.APID))
{
var minfo = msduCache[msdu.APID];
UIConsole.Warn($"Received First Segment for {msdu.APID:X3} but last data wasn't saved to disk yet! Forcing dump.");
// This can only happen for multi-segment file.
string msduFile = Path.Combine(FileHandler.TemporaryFileFolder, minfo.FileName);
string target = Path.Combine(FileHandler.TemporaryFileFolder, $"{msdu.APID:X3}-{LLTools.TimestampMS()}-{Tools.RandomString(8)}");
File.Move(msduFile, target);
if (payloadType == PayloadType.Generic)
{
fileHandleManager.NewFile(new Tuple <string, object>(target, minfo.GenericHeader));
}
else
{
fileHandleManager.NewFile(new Tuple <string, object>(target, minfo.ImageHeader));
}
msduCache.Remove(msdu.APID);
}
var msInfo = new MSDUInfo()
{
APID = msdu.APID,
FileName = msdu.TemporaryFilename,
GenericHeader = payloadType == PayloadType.Generic ? new GRBGenericHeader(msdu.APID, msdu.Data.Skip(8).Take(21).ToArray()) : null,
ImageHeader = payloadType == PayloadType.ImageData ? new GRBImageHeader(msdu.APID, msdu.Data.Skip(8).Take(34).ToArray()) : null,
};
msduCache.Add(msdu.APID, msInfo);
}
else if (msdu.Sequence == SequenceType.LAST_SEGMENT || msdu.Sequence == SequenceType.CONTINUED_SEGMENT)
{
if (!msduCache.ContainsKey(msdu.APID))
{
UIConsole.Warn("Orphan Packet!");
return;
}
}
var msduInfo = msduCache[msdu.APID];
msduInfo.Refresh();
string path = FileHandler.TemporaryFileFolder;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string filename = Path.Combine(FileHandler.TemporaryFileFolder, msduInfo.FileName);
int totalOffset;
if (firstOrSinglePacket)
{
totalOffset = 8;
if (payloadType == PayloadType.Generic)
{
totalOffset += 21;
}
else
{
totalOffset += 34;
}
}
else
{
totalOffset = 8;
}
byte[] dataToSave = msdu.Data.Skip(totalOffset).ToArray();
dataToSave = dataToSave.Take(dataToSave.Length - 4).ToArray(); // Remove CRC
using (FileStream fs = new FileStream(filename, firstOrSinglePacket ? FileMode.Create : FileMode.Append, FileAccess.Write)) {
using (BinaryWriter sw = new BinaryWriter(fs)) {
sw.Write(dataToSave);
sw.Flush();
}
}
if (msdu.Sequence == SequenceType.LAST_SEGMENT || msdu.Sequence == SequenceType.SINGLE_DATA)
{
string target = Path.Combine(FileHandler.TemporaryFileFolder, $"{msdu.APID:X3}-{LLTools.TimestampMS()}-{Tools.RandomString(8)}");
File.Move(filename, target);
if (payloadType == PayloadType.Generic)
{
fileHandleManager.NewFile(new Tuple <string, object>(target, msduInfo.GenericHeader));
}
else
{
fileHandleManager.NewFile(new Tuple <string, object>(target, msduInfo.ImageHeader));
}
msduCache.Remove(msdu.APID);
}
} catch (Exception e) {
UIConsole.Error(String.Format("Exception on FinishMSDU: {0}", e));
}
}
static StatisticsManager()
{
statistics = new List <DBStatistics> ();
lastCheck = LLTools.Timestamp();
lastTimestamp = LLTools.TimestampMS();
}
public static void ImageLabel(ref Bitmap inbmp, GroupData gd, OrganizerData od, GeoConverter gc, bool genLatLonLabel)
{
var usedFontSize = FONT_SIZES [0];
if (inbmp.Width >= 4000)
{
usedFontSize = FONT_SIZES [3];
}
else if (inbmp.Width >= 2000)
{
usedFontSize = FONT_SIZES [2];
}
else if (inbmp.Width >= 1000)
{
usedFontSize = FONT_SIZES [1];
}
var bgBrush = new SolidBrush(Color.Black);
var font = new Font("Arial", usedFontSize);
var fontBrush = new SolidBrush(Color.White);
var upperText = $"{gd.SatelliteName} ({gd.SatelliteLongitude}) - {gd.RegionName}";
var usedLabelSize = PADDING * 2;
using (var g = Graphics.FromImage(inbmp)) {
usedLabelSize += (int)Math.Round(g.MeasureString(upperText, font).Height);
}
var bmp = new Bitmap(inbmp.Width, inbmp.Height + ((genLatLonLabel && gc != null) ? usedLabelSize * 3 : usedLabelSize * 2), inbmp.PixelFormat);
var sf = new StringFormat {
LineAlignment = StringAlignment.Center,
Alignment = StringAlignment.Center
};
if (od.FileHeader != null && od.FileHeader.SubProduct.Name != "None")
{
upperText = upperText + " - " + od.FileHeader.SubProduct.Name;
}
var dt = LLTools.UnixTimeStampToDateTime(od.Timestamp);
var lowerText = $"{dt.ToShortDateString ()} {dt.ToLongTimeString()} UTC - {OSPLABEL}";
using (var g = Graphics.FromImage(bmp)) {
g.CompositingQuality = CompositingQuality.HighQuality;
g.FillRectangle(bgBrush, 0, 0, bmp.Width, bmp.Height);
g.DrawImage(inbmp, 0, usedLabelSize, inbmp.Width, inbmp.Height);
// Upper Label
// var textSize = g.MeasureString (upperText, font);
var rect = new RectangleF(PADDING, 0, bmp.Width - PADDING * 2, usedLabelSize);
g.DrawString(upperText, font, fontBrush, rect, sf);
// Lower Label with Lat/Lon
if (genLatLonLabel && gc != null)
{
var latlon = gc.xy2latlon(inbmp.Width / 2, inbmp.Height / 2);
var lat = latlon.Item1.ToString("##.000000", CultureInfo.InvariantCulture);
var lon = latlon.Item2.ToString("##.000000", CultureInfo.InvariantCulture);
var latLonText = $"Center Coord: ({lat}; {lon})";
lowerText += $"\r\n{latLonText}";
// textSize = g.MeasureString (lowerText, font);
rect = new RectangleF(PADDING, usedLabelSize + inbmp.Height, bmp.Width - PADDING * 2, usedLabelSize * 2);
g.DrawString(lowerText, font, fontBrush, rect, sf);
}
else // Lower Label without Lat/Lon
// textSize = g.MeasureString (lowerText, font);
{
rect = new RectangleF(PADDING, usedLabelSize + inbmp.Height, bmp.Width - PADDING * 2, usedLabelSize);
g.DrawString(lowerText, font, fontBrush, rect, sf);
}
}
inbmp.Dispose();
inbmp = bmp;
}
public static void Main(string[] args)
{
Console.WriteLine($"XRIT Version: {LibInfo.Version}");
AppDomain.CurrentDomain.UnhandledException += CrashReport.DefaultExceptionHandler;
//*
//Organizer org = new Organizer("./himawari");
//org.Update();
//var gd = org.GroupData[1490489400];
//var od = gd.Infrared;
/*
* Console.WriteLine("Initializing organizer");
* Organizer org = new Organizer("/home/lucas/Works/OpenSatelliteProject/split/goesdump/XRITLibraryTest/bin/Debug/channels/Images/Full Disk/");
* org.Update();
* int k = 0;
* int c = 0;
* foreach (var z in org.GroupData.Keys) {
* k = z;
* c++;
* if (c == 2) { // 20 For US
* break;
* }
* }
* var gd = org.GroupData[k];
* var od = gd.Visible;
*
* Console.WriteLine("Initializing GeoConverter");
* var gc = new GeoConverter(gd.SatelliteLongitude, gd.ColumnOffset, gd.LineOffset, gd.ColumnScalingFactor, gd.LineScalingFactor, true, od.Columns);
*
* Console.WriteLine("Generating BMP");
* //var bmp = ImageTools.GenerateFullImage(od);
* var bmp = ImageTools.GenerateFalseColor(gd);
* var mapDrawer = new MapDrawer("/home/lucas/Works/OpenSatelliteProject/split/borders/ne_10m_admin_1_states_provinces.shp");
* //var mapDrawer = new MapDrawer("/home/lucas/Works/OpenSatelliteProject/split/borders/ne_50m_admin_0_countries.shp");
* Console.WriteLine("Drawing Map");
* mapDrawer.DrawMap(ref bmp, gc, Color.Aqua, 2, true);
*
* Console.WriteLine("Drawing LatLon Lines");
* ImageTools.DrawLatLonLines(ref bmp, gc, Color.Brown, 1, true);
*
* bmp.Save("unitedstates.jpg", ImageFormat.Jpeg);
* bmp.Dispose();
* // */
///*
string filename = "./OR_ABI-L2-CMIPF-M3C13_G16_s20170861545382_e20170861556160_c20170861556231.lrit";
string visFilename = "./OR_ABI-L2-CMIPF-M3C02_G16_s20170861545382_e20170861556149_c20170861556217.lrit";
XRITHeader header = FileParser.GetHeaderFromFile(filename);
Console.WriteLine($"Parsing file {header.Filename}");
Regex x = new Regex(@".*\((.*)\)", RegexOptions.IgnoreCase);
var regMatch = x.Match(header.ImageNavigationHeader.ProjectionName);
float satelliteLongitude = float.Parse(regMatch.Groups[1].Captures[0].Value, CultureInfo.InvariantCulture);
var inh = header.ImageNavigationHeader;
var gc = new GeoConverter(satelliteLongitude, inh.ColumnOffset, inh.LineOffset, inh.ColumnScalingFactor, inh.LineScalingFactor);
var od = new OrganizerData();
od.Segments.Add(0, filename);
od.FirstSegment = 0;
od.Columns = header.ImageStructureHeader.Columns;
od.Lines = header.ImageStructureHeader.Lines;
od.ColumnOffset = inh.ColumnOffset;
od.PixelAspect = 1;
var bmp = ImageTools.GenerateFullImage(od);
od = new OrganizerData();
od.Segments.Add(0, visFilename);
od.FirstSegment = 0;
od.Columns = header.ImageStructureHeader.Columns;
od.Lines = header.ImageStructureHeader.Lines;
od.ColumnOffset = inh.ColumnOffset;
od.PixelAspect = 1;
var vbmp = ImageTools.GenerateFullImage(od);
UIConsole.GlobalEnableDebug = true;
var shapeFile = ShapeFiles.InitShapeFiles();
//bmp.Save(filename + "-orig.png", ImageFormat.Png);
//vbmp.Save(visFilename + "-orig.png", ImageFormat.Png);
var mapDrawer = new MapDrawer(shapeFile);
//ImageTools.DrawLatLonLines(ref bmp, gc, Color.Brown);
ImageTools.ApplyCurve(OpenSatelliteProject.Presets.NEW_VIS_FALSE_CURVE, ref vbmp);
vbmp = ImageTools.ToFormat(vbmp, PixelFormat.Format32bppArgb, true);
bmp = ImageTools.ToFormat(bmp, PixelFormat.Format32bppArgb, true);
ImageTools.Apply2DLut(OpenSatelliteProject.Presets.FalseColorLUTVal, ref vbmp, bmp);
var startTime = LLTools.TimestampMS();
mapDrawer.DrawMap(ref vbmp, gc, Color.Yellow, 2, false, true);
var delta = LLTools.TimestampMS() - startTime;
Console.WriteLine($"Took {delta} ms to generate map.");
vbmp.Save(visFilename + ".jpg", ImageFormat.Jpeg);
Bitmap landMap = mapDrawer.GenerateLandMap(gc, bmp.Width, bmp.Height);
landMap.Save(filename + "-landmap.jpg", ImageFormat.Jpeg);
landMap.Dispose();
bmp.Dispose();
return;
// */
/*
* Bitmap test0 = (Bitmap) Bitmap.FromFile("test0.jpg");
* Bitmap test1 = (Bitmap) Bitmap.FromFile("test1.jpg");
* Bitmap overlay = (Bitmap) Bitmap.FromFile("goes13-fulldisk.jpg");
*
* test0 = test0.ToFormat(PixelFormat.Format24bppRgb, true);
*
* overlay.Save("hue.jpg", ImageFormat.Jpeg);
*
* ImageTools.ApplyOverlay(ref test0, overlay);
* test0.Save("test0-ovl.jpg", ImageFormat.Jpeg);
*
* ImageTools.ApplyOverlay(ref test1, overlay);
* test1.Save("test1-ovl.jpg", ImageFormat.Jpeg);
*
* test0.Dispose();
* test1.Dispose();
* overlay.Dispose();
*/
//*
//string dcsFile = "/home/lucas/Works/OpenSatelliteProject/split/goesdump/XRITLibraryTest/bin/Debug/channels/DCS/pM-17085003239-A.dcs";
//List<DCSHeader> d = DCSParser.parseDCS(dcsFile);
//*
//string debugFrames = "/media/ELTN/tmp/demuxdump-1490627438.bin";
//string debugFrames = "/media/ELTN/tmp/debug5/demuxdump-1492732814.bin";
//string debugFrames = "/home/lucas/Works/OpenSatelliteProject/split/issues/trango/3/debug_frames.bin";
//string debugFrames = "/media/ELTN/tmp/debug3/raw_data.bin";
/*
* var mapDrawer = new MapDrawer("/home/lucas/Works/OpenSatelliteProject/split/borders/ne_50m_admin_0_countries.shp");
* var fList = mapDrawer.ShapeFile.Features.ToList ();
* var bmp = new Bitmap (1280, 720, PixelFormat.Format24bppRgb);
* using (var graphics = Graphics.FromImage (bmp)) {
* Brush bgBrush = new SolidBrush (Color.Black);
* Brush polyBrush = new SolidBrush (Color.White);
* graphics.FillRectangle (bgBrush, 0, 0, 1280, 720);
* int o = 0;
* foreach (var fo in fList) {
* Console.WriteLine ($"Writting Geometry {o}");
* Pen pen = new Pen(Color.FromArgb((int)((255.0 * o) / fList.Count), 127, 127), 3);
* o++;
* for (var n = 0; n < fo.NumGeometries; n++) {
* //Console.WriteLine ($"Writting Geometry {n}");
* var fg = fo.GetBasicGeometryN (n);
* var k = fg.Coordinates;
*
* float lastX = float.NaN;
* float lastY = float.NaN;
*
* List<PointF> points = new List<PointF> ();
* foreach (var z in k) {
* float lon = (float)z.X;
* float lat = (float)z.Y;
*
* float X = bmp.Width / 2 + bmp.Width * (lon / 360);
* float Y = bmp.Height / 2 - bmp.Height * (lat / 180);
*
* if (!float.IsNaN (lastX) && !float.IsNaN (lastY)) {
* //graphics.DrawLine (pen, lastX, lastY, X, Y);
* }
* lastX = X;
* lastY = Y;
*
* points.Add (new PointF (X, Y));
* }
* graphics.FillPolygon(polyBrush, points.ToArray());
* }
* }
* }
* Console.WriteLine ("Saving");
* bmp.Save ("/home/lucas/test.png", ImageFormat.Png);
* bmp.Dispose ();
* Console.WriteLine ("Done");
* return;
*/
EventMaster.On("newFile", d => {
var ed = (NewFileReceivedEventData)d.Data;
//Console.WriteLine($"Received event for new file {ed.Name} at {ed.Path}");
//Console.WriteLine(ed.ToString());
});
Console.WriteLine("Hash: " + LibInfo.CommitID);
Console.WriteLine("Log: " + LibInfo.LogLines);
Console.WriteLine("Short Hash: " + LibInfo.ShortCommitID);
Console.WriteLine("Version: " + LibInfo.Version);
//string debugFrames = "/media/ELTN/tmp/demuxdump-1490627438.bin";
//string debugFrames = "/media/ELTN/tmp/G16JuneTest/demuxdump-1496790733.bin";
//string debugFrames = "/media/ELTN/tmp/G16JuneTest/demuxdump-1500179126.bin";
//string debugFrames = "/media/ELTN/tmp/debug14/demuxdump-1495166529.bin";
string debugFrames = "/media/ELTN/tmp/trango/demuxdump-1500736657.bin";
//var mapDrawer = new MapDrawer("/home/lucas/Works/OpenSatelliteProject/split/borders/ne_10m_admin_1_states_provinces.shp");
var im0 = new ImageManager("output/Images/Full Disk/");
var im1 = new ImageManager("output/Images/Northern Hemisphere/");
var im2 = new ImageManager("output/Images/Southern Hemisphere/");
var im3 = new ImageManager("output/Images/Area of Interest/");
var im4 = new ImageManager("output/Images/United States/");
var im5 = new ImageManager("output/Images/FM1/");
var im6 = new ImageManager("output/Images/Unknown/");
im0.InitMapDrawer();
im1.InitMapDrawer();
im2.InitMapDrawer();
im3.InitMapDrawer();
im4.InitMapDrawer();
im5.InitMapDrawer();
im6.InitMapDrawer();
ImageManager.GenerateVisible = true;
ImageManager.GenerateInfrared = true;
ImageManager.GenerateFalseColor = true;
ImageManager.GenerateWaterVapour = true;
ImageManager.GenerateOtherImages = true;
ImageManager.EraseFiles = false;
ImageManager.UseNOAAFileFormat = true;
ImageManager.GenerateLatLonOverlays = true;
ImageManager.GenerateMapOverlays = true;
ImageManager.GenerateLabels = true;
ImageManager.GenerateLatLonLabel = true;
ImageManager.SaveNonOverlay = false;
//im0.Start ();
//im1.Start ();
//im2.Start ();
//im3.Start ();
//im4.Start ();
im5.Start();
//im6.Start ();
// */
//*/
// /*
/*
* DemuxManager dm = new DemuxManager ();
* FileHandler.SkipDCS = true;
* FileHandler.SkipEMWIN = true;
* //const int startFrame = 956000;
* const int startFrame = 0;
* FileStream file = File.OpenRead (debugFrames);
* byte[] data = new byte[892];
* long bytesRead = startFrame * 892;
* long bytesToRead = file.Length;
* int frameN = startFrame;
* file.Position = bytesRead;
* while (bytesRead < bytesToRead) {
* if (frameN % 1000 == 0) {
* //Console.WriteLine("Injecting Frame {0}", frameN);
* }
* bytesRead += file.Read (data, 0, 892);
* dm.parseBytes (data);
* frameN++;
* }
*
* Console.WriteLine ("CRC Fails: {0}", dm.CRCFails);
* Console.WriteLine ("Bugs: {0}", dm.Bugs);
* Console.WriteLine ("Frame Loss: {0}", dm.FrameLoss);
* Console.WriteLine ("Length Fails: {0}", dm.LengthFails);
* Console.WriteLine ("Packets: {0}", dm.Packets);
*
* Console.WriteLine ("Received Products: ");
* foreach (int pID in dm.ProductsReceived.Keys) {
* Console.WriteLine ("\t{0}: {1}", ((NOAAProductID)pID).ToString (), dm.ProductsReceived [pID]);
* }
* //*/
//im.Stop();
//*/
//ProcessFile("/home/lucas/Works/OpenSatelliteProject/split/goesdump/goesdump/bin/Debug/channels/Text/NWSTEXTdat043204159214.lrit");
/*
* Organizer organizer = new Organizer("/home/lucas/Works/OpenSatelliteProject/split/goesdump/goesdump/bin/Debug/channels/Images/Full Disk");
* organizer.Update();
*
* var data = organizer.GroupData;
*
* foreach (var z in data) {
* var mData = z.Value;
* var bmp = ImageTools.GenerateFalseColor(mData);
*
* if (bmp != null) {
* bmp.Save(string.Format("{0}-{1}-{2}-{3}.jpg", mData.SatelliteName, mData.RegionName, "FLSCLR", z.Key), ImageFormat.Jpeg);
* bmp.Dispose();
* mData.IsProcessed = true;
* } else {
* if (mData.Visible.IsComplete && mData.Visible.MaxSegments != 0) {
* bmp = ImageTools.GenerateFullImage(mData.Visible);
* bmp.Save(string.Format("{0}-{1}-{2}-{3}.jpg", mData.SatelliteName, mData.RegionName, "VIS", z.Key), ImageFormat.Jpeg);
* bmp.Dispose();
* }
* if (mData.Infrared.IsComplete && mData.Infrared.MaxSegments != 0) {
* bmp = ImageTools.GenerateFullImage(mData.Infrared);
* bmp.Save(string.Format("{0}-{1}-{2}-{3}.jpg", mData.SatelliteName, mData.RegionName, "IR", z.Key), ImageFormat.Jpeg);
* bmp.Dispose();
* }
* if (mData.WaterVapour.IsComplete && mData.WaterVapour.MaxSegments != 0) {
* bmp = ImageTools.GenerateFullImage(mData.WaterVapour);
* bmp.Save(string.Format("{0}-{1}-{2}-{3}.jpg", mData.SatelliteName, mData.RegionName, "WV", z.Key), ImageFormat.Jpeg);
* bmp.Dispose();
* }
* Console.WriteLine("Not all segments available!");
* }
* }
*
*
* //*/
/*
* string visFile = "/home/lucas/Works/OpenSatelliteProject/split/samples/FD 26-02-17 2106 G13VI.jpg";
* string irFile = "/home/lucas/Works/OpenSatelliteProject/split/samples/FD 26-02-17 2106 G13IR.jpg";
*
* Bitmap vis = new Bitmap(visFile);
* ImageTools.ApplyCurve(Presets.VIS_FALSE_CURVE, ref vis);
* vis.Save("test.jpg", ImageFormat.Jpeg);
* //vis = vis.ToFormat(PixelFormat.Format32bppArgb, true);
*
* Bitmap ir = new Bitmap(irFile);
* ir = ir.ToFormat(PixelFormat.Format32bppArgb, true);
* ImageTools.ApplyLUT(Presets.THERMAL_FALSE_LUT, ref ir, 3);
* ir.Save("test2.jpg", ImageFormat.Jpeg);
*
* ir = ir.ToFormat(PixelFormat.Format32bppArgb);
* ImageTools.CombineHStoV(ref ir, vis);
*
* ir.Save("final.jpg", ImageFormat.Jpeg);
* //*/
do
{
while (!Console.KeyAvailable)
{
Thread.Sleep(1000);
}
} while (Console.ReadKey(true).Key != ConsoleKey.Escape);
}
public Main()
{
#region Create Config File
config.RecordIntermediateFile = config.RecordIntermediateFile;
config.ChannelDataServerName = config.ChannelDataServerName;
config.ChannelDataServerPort = config.ChannelDataServerPort;
config.ConstellationServerName = config.ConstellationServerName;
config.ConstellationServerPort = config.ConstellationServerPort;
config.StatisticsServerName = config.StatisticsServerName;
config.StatisticsServerPort = config.StatisticsServerPort;
config.EnableDCS = config.EnableDCS;
config.EnableEMWIN = config.EnableEMWIN;
config.EraseFilesAfterGeneratingFalseColor = config.EraseFilesAfterGeneratingFalseColor;
config.GenerateFDFalseColor = config.GenerateFDFalseColor;
config.GenerateNHFalseColor = config.GenerateNHFalseColor;
config.GenerateSHFalseColor = config.GenerateSHFalseColor;
config.GenerateUSFalseColor = config.GenerateUSFalseColor;
config.GenerateXXFalseColor = config.GenerateXXFalseColor;
config.HTTPPort = config.HTTPPort;
config.GenerateInfraredImages = config.GenerateInfraredImages;
config.GenerateVisibleImages = config.GenerateVisibleImages;
config.GenerateWaterVapourImages = config.GenerateWaterVapourImages;
config.MaxGenerateRetry = config.MaxGenerateRetry;
config.SysLogServer = config.SysLogServer;
config.SysLogFacility = config.SysLogFacility;
config.UseNOAAFormat = config.UseNOAAFormat;
config.EnableWeatherData = config.EnableWeatherData;
config.TemporaryFileFolder = config.TemporaryFileFolder;
config.FinalFileFolder = config.FinalFileFolder;
config.Save();
#endregion
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
cfd = null;
graphics.PreferredBackBufferWidth = 1280;
graphics.PreferredBackBufferHeight = 720;
graphics.PreferMultiSampling = true;
this.Exiting += (object sender, EventArgs e) => {
//cn.Stop();
};
FileHandler.SkipEMWIN = !config.EnableEMWIN;
FileHandler.SkipDCS = !config.EnableDCS;
FileHandler.SkipWeatherData = !config.EnableWeatherData;
if (config.TemporaryFileFolder != null)
{
if (!LLTools.TestFolderAccess(config.TemporaryFileFolder))
{
UIConsole.GlobalConsole.Error($"Cannot write file to Temporary Folder {config.TemporaryFileFolder}");
throw new ApplicationException($"Cannot write file to Temporary Folder {config.TemporaryFileFolder}");
}
FileHandler.TemporaryFileFolder = config.TemporaryFileFolder;
}
if (config.FinalFileFolder != null)
{
if (!LLTools.TestFolderAccess(config.FinalFileFolder))
{
UIConsole.GlobalConsole.Error($"Cannot write file to Final Folder {config.FinalFileFolder}");
throw new ApplicationException($"Cannot write file to Final Folder {config.FinalFileFolder}");
}
FileHandler.FinalFileFolder = config.FinalFileFolder;
}
ImageManager.EraseFiles = config.EraseFilesAfterGeneratingFalseColor;
ImageManager.GenerateInfrared = config.GenerateInfraredImages;
ImageManager.GenerateVisible = config.GenerateVisibleImages;
ImageManager.GenerateWaterVapour = config.GenerateWaterVapourImages;
ImageManager.MaxRetryCount = config.MaxGenerateRetry;
ImageManager.UseNOAAFileFormat = config.UseNOAAFormat;
Connector.ChannelDataServerName = config.ChannelDataServerName;
Connector.StatisticsServerName = config.StatisticsServerName;
Connector.ConstellationServerName = config.ConstellationServerName;
Connector.ChannelDataServerPort = config.ChannelDataServerPort;
Connector.StatisticsServerPort = config.StatisticsServerPort;
Connector.ConstellationServerPort = config.ConstellationServerPort;
if (LLTools.IsLinux)
{
SyslogClient.SysLogServerIp = config.SysLogServer;
try {
SyslogClient.Send(new Message(config.SysLogFacility, Level.Information, "Your syslog connection is working! OpenSatelliteProject is enabled to send logs."));
} catch (SocketException) {
UIConsole.GlobalConsole.Warn("Your syslog is not enabled to receive UDP request. Please refer to https://opensatelliteproject.github.io/OpenSatelliteProject/");
}
}
string fdFolder = PacketManager.GetFolderByProduct(NOAAProductID.GOES13_ABI, (int)ScannerSubProduct.INFRARED_FULLDISK);
string xxFolder = PacketManager.GetFolderByProduct(NOAAProductID.GOES13_ABI, (int)ScannerSubProduct.INFRARED_AREA_OF_INTEREST);
string nhFolder = PacketManager.GetFolderByProduct(NOAAProductID.GOES13_ABI, (int)ScannerSubProduct.INFRARED_NORTHERN);
string shFolder = PacketManager.GetFolderByProduct(NOAAProductID.GOES13_ABI, (int)ScannerSubProduct.INFRARED_SOUTHERN);
string usFolder = PacketManager.GetFolderByProduct(NOAAProductID.GOES13_ABI, (int)ScannerSubProduct.INFRARED_UNITEDSTATES);
string fmFolder = PacketManager.GetFolderByProduct(NOAAProductID.GOES16_ABI, (int)ScannerSubProduct.NONE);
FDImageManager = new ImageManager(fdFolder);
XXImageManager = new ImageManager(xxFolder);
NHImageManager = new ImageManager(nhFolder);
SHImageManager = new ImageManager(shFolder);
USImageManager = new ImageManager(usFolder);
FMImageManager = new ImageManager(fmFolder);
}
public static string FixFileFolder(string dir, string filename, NOAAProduct product, NOAASubproduct subProduct)
{
string filef = LLTools.FixPathString(filename);
string basedir = FileHandler.FinalFileFolder;
if (product != null && product.ID != -1)
{
// New way
string folderName = UnknownDataFolder;
if (product.ID == (int)NOAAProductID.GOES16_ABI || product.ID == (int)NOAAProductID.GOES17_ABI)
{
folderName = Path.Combine(ImagesFolder, "FM1");
}
else if (product.ID == (int)NOAAProductID.HIMAWARI8_ABI)
{
folderName = Path.Combine(ImagesFolder, "Full Disk");
}
else if (product.ID == (int)NOAAProductID.GOES13_ABI || product.ID == (int)NOAAProductID.GOES15_ABI || product.ID == (int)NOAAProductID.ABI_RELAY)
{
switch (subProduct.ID)
{
case (int)ScannerSubProduct.INFRARED_AREA_OF_INTEREST:
case (int)ScannerSubProduct.VISIBLE_AREA_OF_INTEREST:
case (int)ScannerSubProduct.WATERVAPOUR_AREA_OF_INTEREST:
folderName = Path.Combine(ImagesFolder, "Area of Interest");
break;
case (int)ScannerSubProduct.INFRARED_FULLDISK:
case (int)ScannerSubProduct.VISIBLE_FULLDISK:
case (int)ScannerSubProduct.WATERVAPOUR_FULLDISK:
folderName = Path.Combine(ImagesFolder, "Full Disk");
break;
case (int)ScannerSubProduct.INFRARED_NORTHERN:
case (int)ScannerSubProduct.VISIBLE_NORTHERN:
case (int)ScannerSubProduct.WATERVAPOUR_NORTHERN:
folderName = Path.Combine(ImagesFolder, "Northern Hemisphere");
break;
case (int)ScannerSubProduct.INFRARED_SOUTHERN:
case (int)ScannerSubProduct.VISIBLE_SOUTHERN:
case (int)ScannerSubProduct.WATERVAPOUR_SOUTHERN:
folderName = Path.Combine(ImagesFolder, "Southern Hemisphere");
break;
case (int)ScannerSubProduct.INFRARED_UNITEDSTATES:
case (int)ScannerSubProduct.VISIBLE_UNITEDSTATES:
case (int)ScannerSubProduct.WATERVAPOUR_UNITEDSTATES:
folderName = Path.Combine(ImagesFolder, "United States");
break;
default:
folderName = Path.Combine(ImagesFolder, UnknownDataFolder);
break;
}
}
else
{
switch (product.ID)
{
case (int)NOAAProductID.DCS:
folderName = DCSFolder;
break;
case (int)NOAAProductID.EMWIN:
folderName = EMWINFolder;
break;
case (int)NOAAProductID.NOAA_TEXT:
folderName = TextFolder;
break;
case (int)NOAAProductID.OTHER_SATELLITES_1:
case (int)NOAAProductID.OTHER_SATELLITES_2:
folderName = OtherSatellitesFolder;
break;
case (int)NOAAProductID.WEATHER_DATA:
if (filename.Contains("KWIN"))
{
folderName = EMWINFolder; // HRIT EMWIN
}
else
{
folderName = WeatherDataFolder;
}
break;
default:
if (filename.Contains("KWIN"))
{
folderName = EMWINFolder; // HRIT EMWIN
}
else
{
folderName = UnknownDataFolder;
}
break;
}
}
dir = Path.Combine(basedir, folderName);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
filef = Path.Combine(dir, filename);
}
else
{
// Old way
string folderName;
if (dcsRegex.IsMatch(filename))
{
folderName = DCSFolder;
}
else if (xxRegex.IsMatch(filename))
{
folderName = Path.Combine(ImagesFolder, "Area of Interest");
}
else if (fdRegex.IsMatch(filename))
{
folderName = Path.Combine(ImagesFolder, "Full Disk");
}
else if (chartRegex.IsMatch(filename))
{
folderName = WeatherDataFolder;
}
else if (gosRegex.IsMatch(filename))
{
folderName = Path.Combine(ImagesFolder, UnknownDataFolder);
}
else if (textRegex.IsMatch(filename))
{
folderName = TextFolder;
}
else
{
folderName = UnknownDataFolder;
}
dir = Path.Combine(basedir, folderName);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
filef = Path.Combine(dir, filename);
}
return(filef);
}
public static void CLApply2DLUT(ComputeContext context)
{
ComputeImageFormat format = new ComputeImageFormat(ComputeImageChannelOrder.Bgra, ComputeImageChannelType.UnsignedInt8);
var startTime = LLTools.TimestampMS();
#region Visible / Temporary Source
BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat);
ComputeImage2D source0 = new ComputeImage2D(context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.CopyHostPointer, format, bmp.Width, bmp.Height, bitmapData.Stride, bitmapData.Scan0);
bmp.UnlockBits(bitmapData);
#endregion
#region Infrared Source
bitmapData = irBmp.LockBits(new Rectangle(0, 0, irBmp.Width, irBmp.Height), ImageLockMode.ReadOnly, irBmp.PixelFormat);
ComputeImage2D source1 = new ComputeImage2D(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, format, irBmp.Width, irBmp.Height, bitmapData.Stride, bitmapData.Scan0);
irBmp.UnlockBits(bitmapData);
#endregion
#region Output
ComputeImage2D output = new ComputeImage2D(context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.AllocateHostPointer, format, bmp.Width, bmp.Height, 0, IntPtr.Zero);
#endregion
#region Variable Initialization
ComputeEventList eventList = new ComputeEventList();
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
#region Apply Curve
applyCurveKernel.SetMemoryArgument(0, source0);
applyCurveKernel.SetMemoryArgument(1, output);
applyCurveKernel.SetMemoryArgument(2, curveLutBuffer);
#endregion
#region Apply LUT 2D
apply2DLUTKernel.SetMemoryArgument(0, source1);
apply2DLUTKernel.SetMemoryArgument(1, output);
apply2DLUTKernel.SetMemoryArgument(2, source0);
apply2DLUTKernel.SetMemoryArgument(3, lut2DBuffer);
#endregion
#region Reprojection
var latRangeBuff = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, latRange);
var lonRangeBuff = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, lonRange);
var coverageBuff = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, coverage);
var trimBuff = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, trim);
var sizeBuff = new ComputeBuffer <uint>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, size);
reprojectKernel.SetMemoryArgument(0, source0);
reprojectKernel.SetMemoryArgument(1, output);
reprojectKernel.SetValueArgument(2, satelliteLongitude);
reprojectKernel.SetValueArgument(3, coff);
reprojectKernel.SetValueArgument(4, cfac);
reprojectKernel.SetValueArgument(5, loff);
reprojectKernel.SetValueArgument(6, lfac);
reprojectKernel.SetValueArgument(7, (uint)(fixAspect ? 1 : 0));
reprojectKernel.SetValueArgument(8, aspectRatio);
reprojectKernel.SetMemoryArgument(9, latRangeBuff);
reprojectKernel.SetMemoryArgument(10, lonRangeBuff);
reprojectKernel.SetMemoryArgument(11, coverageBuff);
reprojectKernel.SetMemoryArgument(12, trimBuff);
reprojectKernel.SetMemoryArgument(13, sizeBuff);
#endregion
#endregion
#region Run Pipeline
UIConsole.Log("Executing curve kernel");
commands.Execute(applyCurveKernel, null, new long[] { bmp.Width, bmp.Height }, null, eventList);
UIConsole.Log("Executing LUT2D kernel");
commands.Execute(apply2DLUTKernel, null, new long[] { bmp.Width, bmp.Height }, null, eventList);
UIConsole.Log("Executing kernel");
commands.Execute(reprojectKernel, null, new long[] { bmp.Width, bmp.Height }, null, eventList);
#endregion
#region Dump Bitmap
UIConsole.Log("Dumping bitmap");
Bitmap obmp = new Bitmap(bmp.Width, bmp.Height, bmp.PixelFormat);
BitmapData bmpData = obmp.LockBits(new Rectangle(0, 0, obmp.Width, obmp.Height), ImageLockMode.ReadWrite, obmp.PixelFormat);
commands.ReadFromImage(output, bmpData.Scan0, true, null);
obmp.UnlockBits(bmpData);
var delta = LLTools.TimestampMS() - startTime;
UIConsole.Log($"Took {delta} ms to Apply Curve -> Apply Lut2D (FalseColor) -> Reproject");
UIConsole.Log("Saving bitmap");
obmp.Save("teste.png");
UIConsole.Log("Done");
bmp.Save("original.png");
#endregion
}
