void ResizeTriggerImgBox(ScanConfig config)
{
switch (config)
{
case ScanConfig.Trigger_1:
windowTrig0.Width = 560;
imgboxTrig0.Width = 560;
break;
case ScanConfig.Trigger_2:
windowTrig0.Width = 280;
windowTrig1.Width = 280;
imgboxTrig0.Width = 280;
imgboxTrig1.Width = 280;
break;
case ScanConfig.Trigger_4:
windowTrig0.Width = 140;
windowTrig1.Width = 140;
windowTrig2.Width = 140;
windowTrig3.Width = 140;
imgboxTrig0.Width = 140;
imgboxTrig1.Width = 140;
imgboxTrig2.Width = 140;
imgboxTrig3.Width = 140;
break;
}
}
private void saveScanConfig(string fileName)
{
ScanConfig sc = new ScanConfig();
sc.Name = textBox_scanner_name.Text;
sc.Description = richTextBox_Scanner_Description.Text;
sc.Type = comboBox_finding_type.Text;
sc.Risk = comboBox_risk.Text;
//add patterns
foreach (var item in listBox_Scan.Items)
{
if (!sc.Patterns.Contains(item.ToString()))
{
sc.Patterns.Add(item.ToString());
}
}
//add file extensions
foreach (var item in listBox_FileExt.Items)
{
if (!sc.FileExtensions.Contains(item.ToString()))
{
sc.FileExtensions.Add(item.ToString());
}
}
//serialize and save to ParaData/ScanConfigs
ParaObjSerializer pos = new ParaObjSerializer();
pos.SaveParaObj(fileName, sc);
}
/// <summary>The get scan config.</summary>
/// <param name="type">The type.</param>
/// <returns>The <see cref="ScanConfig"/>.</returns>
private ScanConfig GetScanConfig(DeviceType type)
{
ScanConfig config = new ScanConfig()
{
ScanType = BleScanType.LowLatency
};
switch (type)
{
case DeviceType.Spirometer:
// device config here
break;
case DeviceType.Oximeter:
// device config here
break;
case DeviceType.None:
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
return(config);
}
protected virtual void StartNewScanner(ScanConfig config)
{
this.newCallback = new LollipopScanCallback(args => this.Scanned?.Invoke(this, args));
var scanMode = this.ToNative(config.ScanType);
var filterBuilderList = new List <ScanFilter>();
if (config.ServiceUuids != null && config.ServiceUuids.Count > 0)
{
foreach (var uuid in config.ServiceUuids)
{
var filterBuilder = new ScanFilter.Builder();
filterBuilder.SetServiceUuid(uuid.ToParcelUuid());
filterBuilderList.Add(filterBuilder.Build());
}
}
else
{
var filterBuilder = new ScanFilter.Builder();
filterBuilderList.Add(filterBuilder.Build());
}
//new ScanFilter.Builder().SetDeviceAddress().Set
this.manager.Adapter.BluetoothLeScanner.StartScan(
filterBuilderList,
new ScanSettings
.Builder()
.SetScanMode(scanMode)
.Build(),
this.newCallback
);
}
public async void EpiScan(ScanConfig config)
{
await FL.MoveStartOrigin(config, 0);
bool?result;
switch (config)
{
case ScanConfig.Trigger_1:
result = await FL.ScanMomenet(config, 4);
break;
case ScanConfig.Trigger_2:
result = await FL.ScanMomenet(config, 4);
break;
case ScanConfig.Trigger_4:
result = await await FL.ScanMomenet(config, 4)
.ContinueWith(x => FL.MoveStartOrigin(config, 1))
.ContinueWith(x => FL.ScanMomenet(config, 4))
.ContinueWith(x => FL.MoveStartOrigin(config, 2))
.ContinueWith(x => FL.ScanMomenet(config, 4))
.ContinueWith(x => FL.MoveStartOrigin(config, 3));
break;
}
}
public void Setup()
{
_annotator = new Annotator
{
Config = ScanConfig.Create(new[] { "c:\\tools\\xampp\\htdocs", "test" })
};
}
protected virtual IObservable <ScanResult> NewScan(ScanConfig config) => Observable.Create <ScanResult>(ob =>
{
var cb = new LollipopScanCallback((native, rssi, sr) =>
{
var scanResult = this.ToScanResult(native, rssi, new AdvertisementData(sr));
ob.OnNext(scanResult);
});
var scanMode = this.ToNative(config.ScanType);
var scanFilters = new List <ScanFilter>();
if (config.ServiceUuids != null && config.ServiceUuids.Count > 0)
{
foreach (var guid in config.ServiceUuids)
{
var uuid = guid.ToParcelUuid();
scanFilters.Add(new ScanFilter.Builder()
.SetServiceUuid(uuid)
.Build()
);
}
}
this.manager.Adapter.BluetoothLeScanner.StartScan(
scanFilters,
new ScanSettings
.Builder()
.SetScanMode(scanMode)
.Build(),
cb
);
return(() => this.manager.Adapter.BluetoothLeScanner?.StopScan(cb));
});
void LoadConfig(ScanConfig mode)
{
ServerName = DalsaCam_ccf_Data.ServerName;
ResourceIndex = DalsaCam_ccf_Data.ResourceIndex;
// If need custom path, insert config file path to ConfigFileName
switch (mode)
{
case ScanConfig.nonTrigger:
ConfigFileName = DalsaCam_ccf_Data.ConfigFile_Non;
ConfigFile = DalsaCam_ccf_Data.ConfigFileNameBase + ConfigFileName;
break;
case ScanConfig.Trigger_1:
ConfigFileName = DalsaCam_ccf_Data.ConfigFile_2;
ConfigFile = DalsaCam_ccf_Data.ConfigFileNameBase + ConfigFileName;
break;
case ScanConfig.Trigger_2:
ConfigFileName = DalsaCam_ccf_Data.ConfigFile_2;
ConfigFile = DalsaCam_ccf_Data.ConfigFileNameBase + ConfigFileName;
break;
case ScanConfig.Trigger_4:
ConfigFileName = DalsaCam_ccf_Data.ConfigFile_4;
ConfigFile = DalsaCam_ccf_Data.ConfigFileNameBase + ConfigFileName;
break;
}
}
private void scanDir(string directory)
{
try
{
ScanConfig scfg = new ScanConfig();
scfg.Name = textBox_scanner_name.Text;
scfg.Type = comboBox_finding_type.Text;
scfg.Risk = comboBox_risk.Text;
//add files
FileUtil fu = new FileUtil();
scfg.Files = fu.GetFiles(directory);
//add extensions
foreach (var item in listBox_FileExt.Items)
{
scfg.FileExtensions.Add(item.ToString());
}
//add paterns from listbox
foreach (var item in listBox_Scan.Items)
{
scfg.Patterns.Add(item.ToString());
}
//Scan here and add results
Scanner sc = new Scanner();
WorkingScans.Add(sc.GetResults(scfg));
updateScans();
}
catch (Exception ex)
{
richTextBox_error.Text = ex.Message;
}
}
private void openScanConfig(string filePath)
{
try
{
ParaObjSerializer pos = new ParaObjSerializer();
ScanConfig sc = pos.LoadScanConfig(filePath);
textBox_scanner_name.Text = sc.Name;
richTextBox_Scanner_Description.Text = sc.Description;
comboBox_finding_type.Text = sc.Type;
comboBox_risk.Text = sc.Risk;
//add patterns to list box
listBox_Scan.Items.Clear();
foreach (var item in sc.Patterns)
{
listBox_Scan.Items.Add(item);
}
//add file extensions to list box
listBox_FileExt.Items.Clear();
foreach (var item in sc.FileExtensions)
{
listBox_FileExt.Items.Add(item);
}
}
catch (Exception ex)
{
richTextBox_error.Text = ex.Message;
}
}
public async Task UpdateScanConfigAsync()
{
Mock <ContainerAnalysisV1Beta1.ContainerAnalysisV1Beta1Client> mockGrpcClient = new Mock <ContainerAnalysisV1Beta1.ContainerAnalysisV1Beta1Client>(MockBehavior.Strict);
UpdateScanConfigRequest expectedRequest = new UpdateScanConfigRequest
{
ScanConfigName = new ScanConfigName("[PROJECT]", "[SCAN_CONFIG]"),
ScanConfig = new ScanConfig(),
};
ScanConfig expectedResponse = new ScanConfig
{
ScanConfigName = new ScanConfigName("[PROJECT]", "[SCAN_CONFIG]"),
Description = "description-1724546052",
Enabled = false,
};
mockGrpcClient.Setup(x => x.UpdateScanConfigAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <ScanConfig>(Task.FromResult(expectedResponse), null, null, null, null));
ContainerAnalysisV1Beta1Client client = new ContainerAnalysisV1Beta1ClientImpl(mockGrpcClient.Object, null);
ScanConfigName name = new ScanConfigName("[PROJECT]", "[SCAN_CONFIG]");
ScanConfig scanConfig = new ScanConfig();
ScanConfig response = await client.UpdateScanConfigAsync(name, scanConfig);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task EpiScanAsync(ScanConfig config)
{
await FL.MoveStartOrigin(config, 0);
bool?result;
switch (config)
{
case ScanConfig.Trigger_1:
result = await FL.ScanMomenet(config, 4);
break;
case ScanConfig.Trigger_2:
result = await FL.ScanMomenet(config, 4);
break;
case ScanConfig.Trigger_4:
result = await await FL.ScanMomenet(config, 4)
.ContinueWith(x => FL.MoveStartOrigin(config, 1), TaskContinuationOptions.ExecuteSynchronously)
.ContinueWith(x => FL.ScanMomenet(config, 4), TaskContinuationOptions.ExecuteSynchronously)
.ContinueWith(x => FL.MoveStartOrigin(config, 2), TaskContinuationOptions.ExecuteSynchronously)
.ContinueWith(x => FL.ScanMomenet(config, 4), TaskContinuationOptions.ExecuteSynchronously)
.ContinueWith(x => FL.MoveStartOrigin(config, 3), TaskContinuationOptions.ExecuteSynchronously);
break;
}
}
public Task <Point[][]> GetContoursAsync(byte [ , , ] input, ScanConfig config)
{
int areaup = 0;
int areadw = 0;
// insert config => areaup de
return(FL.GetContourList(input, areaup, areadw));
}
void StgReadyTrigScan(int triggerNum, ScanConfig config)
{
MoveXYstg("Y", TrigScanData.StartYPos[config]);
MoveXYstg("X", TrigScanData.StartXPos[config] + TrigScanData.XStep_Size * triggerNum);
Stg.WaitEps("Y")(TrigScanData.StartYPos[config], 0.005);
Stg.WaitEps("X")(TrigScanData.StartXPos[config], 0.005);
Stg.SetSpeed("Y")(TrigScanData.Scan_Stage_Speed);
}
public IObservable <ScanResult> Scan(ScanConfig config)
{
this.Devices.Clear();
var obs = CrossBleAdapter.AndroidConfiguration.UseNewScanner
? this.NewScan(config)
: this.PreLollipopScan(config);
return(obs);
}
public static int ToResizeH(
this ScanConfig src)
{
return(src.Match()
.With(x => x == ScanConfig.Trigger_1, 24000)
.With(x => x == ScanConfig.Trigger_2, 36000)
.With(x => x == ScanConfig.Trigger_4, 36000)
.Do());
}
/// <summary>Snippet for GetScanConfig</summary>
public void GetScanConfig()
{
// Snippet: GetScanConfig(ScanConfigName,CallSettings)
// Create client
ContainerAnalysisV1Beta1Client containerAnalysisV1Beta1Client = ContainerAnalysisV1Beta1Client.Create();
// Initialize request argument(s)
ScanConfigName name = new ScanConfigName("[PROJECT]", "[SCAN_CONFIG]");
// Make the request
ScanConfig response = containerAnalysisV1Beta1Client.GetScanConfig(name);
// End snippet
}
public static TestSettings FromScanConfig(ScanConfig config)
{
return new TestSettings()
{
Host = config.Server,
Port = config.Port,
Webroot = config.WebRoot,
LaunchInAppDomain = true,
LogConsoleOutput = false,
};
}
public static TestSettings FromScanConfig(ScanConfig config)
{
return(new TestSettings()
{
Host = config.Server,
Port = config.Port,
Webroot = config.WebRoot,
LaunchInAppDomain = true,
LogConsoleOutput = false,
});
}
void Window1_Loaded(object sender, RoutedEventArgs e)
{
SizeToContent = SizeToContent.WidthAndHeight;
if (File.Exists(_configFile))
{
Config = ScanConfig.Deserialize(_configFile);
}
SetAppsEnabled();
}
private void Scan()
{
// Scan for any Bluetooth device
// For Android: if we scan using the given config-object we can command the scanner to only scan for Bean-devices
// This doesn't work in iOS (error in the NuGet-package)
var config = new ScanConfig();
if (Device.OS == TargetPlatform.Android)
{
config.ServiceUuid = Constants.BeanServiceAdvertisingUuid;
}
_scanner = CrossBleAdapter.Current.Scan(config).Subscribe(scanResult =>
{
// Only add the Bluetooth devices that have the right advertisement UUID
// You should be using "new ScanConfig ..." as a parameter in "Scan()" but that's not doing anything (as of today)...
if (Device.OS == TargetPlatform.iOS)
{
// Since we are unable to use the config-object in iOS, we look at the advertisement-service once we've discovered a device
// If this ID isn't equal to our Constant, don't add the device
if (scanResult.AdvertisementData == null || scanResult.AdvertisementData.ServiceUuids == null || scanResult.AdvertisementData.ServiceUuids.Count() == 0 || scanResult.AdvertisementData.ServiceUuids[0] != Constants.BeanServiceAdvertisingUuid)
{
return;
}
}
// First check if the found device is already added to the collection
// The easiest way to do this, is by Id (UUID)
if (IsDeviceAlreadyAdded(scanResult.Device))
{
// If the device is already added to the collection, no need to re-add it
return;
}
// Device is not added yet, so add it
// First create a new instance of "BLEDevice"
var device = new BLEDevice
{
Id = scanResult.Device.Uuid,
Name = scanResult.Device.Name,
NativeDevice = scanResult.Device
};
// Next add this to the collection
// Since "Devices" is an ObservableCollection the UI will automatically be notified
// If added to prevent emty devices
if (!string.IsNullOrWhiteSpace(device.Name))
{
Devices.Add(device);
}
});
}
public void StartScan(bool forcePreLollipop, ScanConfig config)
{
this.Devices.Clear();
if (!forcePreLollipop && Build.VERSION.SdkInt >= BuildVersionCodes.Lollipop)
{
this.StartNewScanner(config);
}
else
{
this.StartPreLollipopScan();
}
}
public Task <bool?> MoveStartOrigin(ScanConfig config, int count)
{
Task <bool?> scanStartPos = Task.Run <bool?>(() => {
Stg.MoveAbsE("X", SetData.StartXPos[config])
.MoveAbsE("Y", SetData.StartYPos[config] + SetData.XStep_Size * count)
.WaitStatusE("X")
.WaitStatusE("Y");
return(true);
});
return(scanStartPos);
}
void StgReadyTrigScan(int triggerNum, ScanConfig config)
{
Console.WriteLine($"Stage Ready Line NUmber = {triggerNum}");
var nextYpos = TrigScanData.StartYPos[config];
var nextXpos = TrigScanData.StartXPos[config] - TrigScanData.XStep_Size * triggerNum;
MoveXYstg("Y", nextYpos);
MoveXYstg("X", nextXpos);
Stg.WaitEps("Y")(nextYpos, 0.005);
Stg.WaitEps("X")(nextXpos, 0.005);
Stg.SetSpeed("Y")(TrigScanData.Scan_Stage_Speed);
}
/// <summary>Snippet for GetScanConfig</summary>
public void GetScanConfigRequestObject()
{
// Snippet: GetScanConfig(GetScanConfigRequest, CallSettings)
// Create client
WebSecurityScannerClient webSecurityScannerClient = WebSecurityScannerClient.Create();
// Initialize request argument(s)
GetScanConfigRequest request = new GetScanConfigRequest {
Name = "",
};
// Make the request
ScanConfig response = webSecurityScannerClient.GetScanConfig(request);
// End snippet
}
// DefectInfo
public ScanTempData(ScanConfig type, int bufflimit)
{
CurrentType = type;
BufferLimit = bufflimit;
SeperatedImg = new byte [bufflimit] [, , ];
SeperatedBoxedImg = new byte [bufflimit] [, , ];
SeperatedResizedImg = new byte [bufflimit] [, , ];
EpiDefectList = new List <DefectRawData> [bufflimit];
OffsetData = new int[bufflimit];
OffsetData [0] = 0;
ResizeWidth = BufferLimit * 12000 < 40000 ? 12000 : 40000 / BufferLimit;
ResizeHeight = 40000;
}
/// <summary>Snippet for GetScanConfig</summary>
public void GetScanConfig_RequestObject()
{
// Snippet: GetScanConfig(GetScanConfigRequest,CallSettings)
// Create client
ContainerAnalysisV1Beta1Client containerAnalysisV1Beta1Client = ContainerAnalysisV1Beta1Client.Create();
// Initialize request argument(s)
GetScanConfigRequest request = new GetScanConfigRequest
{
ScanConfigName = new ScanConfigName("[PROJECT]", "[SCAN_CONFIG]"),
};
// Make the request
ScanConfig response = containerAnalysisV1Beta1Client.GetScanConfig(request);
// End snippet
}
protected virtual IObservable <ScanResult> NewScan(ScanConfig config) => Observable.Create <ScanResult>(ob =>
{
this.callbacks = new LollipopScanCallback((native, rssi, sr) =>
{
var scanResult = this.ToScanResult(native, rssi, new AdvertisementData(sr));
ob.OnNext(scanResult);
});
var builder = new ScanSettings.Builder();
var scanMode = this.ToNative(config.ScanType);
builder.SetScanMode(scanMode);
if (CrossBleAdapter.AndroidConfiguration.AdvancedScannerSettings)
{
if (config.MatchMode != null)
{
builder.SetMatchMode(this.ToNative(config.MatchMode.Value));
}
if (config.NumOfMatches != null)
{
builder.SetNumOfMatches((int)this.ToNative(config.NumOfMatches.Value));
}
}
var scanFilters = new List <ScanFilter>();
if (config.ServiceUuids != null && config.ServiceUuids.Count > 0)
{
foreach (var guid in config.ServiceUuids)
{
var uuid = guid.ToParcelUuid();
scanFilters.Add(new ScanFilter.Builder()
.SetServiceUuid(uuid)
.Build()
);
}
}
if (config.AndroidUseScanBatching && this.manager.Adapter.IsOffloadedScanBatchingSupported)
{
builder.SetReportDelay(100);
}
this.manager.Adapter.BluetoothLeScanner.StartScan(
scanFilters,
builder.Build(),
this.callbacks
);
return(() => this.manager.Adapter.BluetoothLeScanner?.StopScan(this.callbacks));
});
/// <summary>Snippet for GetScanConfigAsync</summary>
public async Task GetScanConfigAsync()
{
// Snippet: GetScanConfigAsync(ScanConfigName,CallSettings)
// Additional: GetScanConfigAsync(ScanConfigName,CancellationToken)
// Create client
ContainerAnalysisV1Beta1Client containerAnalysisV1Beta1Client = await ContainerAnalysisV1Beta1Client.CreateAsync();
// Initialize request argument(s)
ScanConfigName name = new ScanConfigName("[PROJECT]", "[SCAN_CONFIG]");
// Make the request
ScanConfig response = await containerAnalysisV1Beta1Client.GetScanConfigAsync(name);
// End snippet
}
public ScanResults GetResults(ScanConfig sc)
{
try
{
ScanResults results = new ScanResults();
ScannerResults srs = new ScannerResults(sc.Name);
results.Name = srs.Name;
results.ScanTime = DateTime.Now;
results.Risk = sc.Risk;
results.Type = sc.Type;
//foreach file in files scan
foreach (var f in sc.Files)
{
//switch on file extension
try
{
FileInfo fi = new FileInfo(f);
foreach (var x in sc.FileExtensions)
{
if (fi.Extension == x)
{
//foreach pattern in patterns scan file
foreach (var p in sc.Patterns)
{
//scan andadd result to results
results.Results.Add(getResult(f, p, sc.Name, sc.Description,
sc.Risk, sc.Type));
}
}
}
}
catch (Exception ex)
{
//TODO: add logging
//throw new Exception("Error on FileInfo " + f + " " + ex.Message);
}
}
//return results
return(results);
}
catch (Exception ex)
{
throw new ParadigmException(ex.Message);
}
}
/// <summary>Snippet for CreateScanConfig</summary>
public void CreateScanConfigRequestObject()
{
// Snippet: CreateScanConfig(CreateScanConfigRequest, CallSettings)
// Create client
WebSecurityScannerClient webSecurityScannerClient = WebSecurityScannerClient.Create();
// Initialize request argument(s)
CreateScanConfigRequest request = new CreateScanConfigRequest
{
Parent = "",
ScanConfig = new ScanConfig(),
};
// Make the request
ScanConfig response = webSecurityScannerClient.CreateScanConfig(request);
// End snippet
}
public StaticAnalysisEngine(ScanConfig config)
{
_config = config;
}
