public AlbumMapper(IImageAlbumService imageAlbumService, IImageConverter imageConverter)
{
this._imageAlbumService = imageAlbumService;
this._imageConverter = imageConverter;
string temp = AppDomain.CurrentDomain.GetData("DataDirectory") as string;
this._pathToContentFolder = Path.Combine(temp, @"BSUIR.TermWork.ImageViewer.UI.WebSite\Content");
}
protected override void Context()
{
var factory = new BuildTrackerFactory();
_outputDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestResults", "Artifacts");
var workDir = Path.Combine(_outputDir, "WORK");
var plotDir = Path.Combine(workDir, Constants.ArtifactFolderForPlots);
if (Directory.Exists(plotDir))
{
Directory.Delete(plotDir, true);
}
Directory.CreateDirectory(plotDir);
_artifact1 = Path.Combine(plotDir, "oneArtifact.pdf");
using (var writer = new StreamWriter(_artifact1))
{
writer.Write("BLAH");
}
var pdfReportFullPath = Path.Combine(_outputDir, string.Concat("Report", ".pdf"));
_tracker = factory.CreateFor <BuildTracker>(pdfReportFullPath, "WORK");
_imageConverter = new ImageConverter();
sut = new ArtifactsManager(_imageConverter);
}
/// <summary>
/// Zpl Download Graphics
/// </summary>
/// <param name="storageDevice"></param>
/// <param name="imageName"></param>
/// <param name="imageData"></param>
/// <param name="isCompressionActive"></param>
/// <param name="imageConverter"></param>
public ZplDownloadGraphics(
char storageDevice,
string imageName,
byte[] imageData,
bool isCompressionActive = true,
IImageConverter imageConverter = default)
: base(storageDevice)
{
if (imageName.Length > 8)
{
new ArgumentException("maximum length of 8 characters exceeded", nameof(imageName));
}
_extension = "GRF"; //Fixed
ImageName = imageName;
ImageData = imageData;
if (imageConverter == default)
{
imageConverter = new ImageSharpImageConverter();
}
_isCompressionActive = isCompressionActive;
_imageConverter = imageConverter;
}
public UserEventHandlers(IIdentityMapper identityMapper, IImageConverter imageConverter)
{
Contract.Requires <ArgumentNullException>(identityMapper != null, "identityMapper");
Contract.Requires <ArgumentNullException>(imageConverter != null, "imageStringConverter");
_identityMapper = identityMapper;
_imageConverter = imageConverter;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServicesController"/> class.
/// </summary>
/// <param name="imageService">The image service.</param>
/// <param name="imageConverter">The image converter.</param>
/// <param name="queueFileService">The queue file service.</param>
public ServicesController(IImageService imageService,
IImageConverter imageConverter, IQueueFileService queueFileService)
{
_imageConverter = imageConverter;
_queueFileService = queueFileService;
_imageService = imageService;
}
public LightingEnhancementTools(IImageConverter converter, IChangeBrightnessAlgorithm changeBrightnessAlgorithm,
IContrastStretchingAlgorithm contrastStretchingAlgorithm)
{
Converter = converter;
ChangeBrightnessAlgorithm = changeBrightnessAlgorithm;
ContrastStretchingAlgorithm = contrastStretchingAlgorithm;
}
private static void ConfigureFileMaps(IImageConverter imageConverter)
{
// Map a file to a base64 string if available.
var fileConfig = new MapConfig <object, object>();
fileConfig.AfterMapAction = (content, model) =>
{
var fileProperties = model.GetType().GetProperties().Where(pr => pr.GetCustomAttributes(typeof(ImageAttribute), true).Any());
foreach (var fileProperty in fileProperties)
{
var file = model.GetPropertyValue(fileProperty.Name) as FileDisplayModel;
var attribute = fileProperty.GetAttribute <ImageAttribute>();
var sizeX = string.IsNullOrWhiteSpace(attribute.WidthProperty) ? attribute.Width : (int)model.GetPropertyValue(attribute.WidthProperty);
var sizeY = string.IsNullOrWhiteSpace(attribute.HeightProperty) ? attribute.Height : (int)model.GetPropertyValue(attribute.HeightProperty);
string path = null;
if (file != null && file.Folder != null)
{
var imagePath = string.Format("{0}.{1}", System.IO.Path.Combine(file.Folder, file.Path, file.FileName), file.Extension);
path = imageConverter.ImageAsPath(imagePath, sizeX, sizeY, attribute.KeepAspectRatio);
}
if (model.HasProperty(fileProperty.Name + "Path"))
{
model.SetPropertyValue(fileProperty.Name + "Path", path);
}
}
};
DataMapper.RegisterMapConfig(fileConfig);
}
public void DoesNotThrowIfMultipleConvertersRegistered()
{
IServiceCollection services = new ServiceCollection();
ImageLoaderCoreSetup.Configure(services);
IImageConverter ic1 = Substitute.For <IImageConverter>();
ic1.SupportedExtensions.Returns(new[]
{
".jpg",
".jpeg"
});
services = services.AddSingleton(ic1);
IImageConverter ic2 = Substitute.For <IImageConverter>();
ic2.SupportedExtensions.Returns(new[]
{
".png"
});
services = services.AddSingleton(ic2);
IServiceProvider serviceProvider = services.BuildServiceProvider();
IImageLoader il = serviceProvider.GetRequiredService <IImageLoader>();
Assert.NotNull(il);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServicesController"/> class.
/// </summary>
/// <param name="imageService">The image service.</param>
/// <param name="imageConverter">The image converter.</param>
/// <param name="queueFileService">The queue file service.</param>
public ServicesController(IImageService imageService,
IImageConverter imageConverter, IQueueFileService queueFileService)
{
_imageConverter = imageConverter;
_queueFileService = queueFileService;
_imageService = imageService;
}
/// <summary>
/// Convert images used in blog posts into WebP format.
/// </summary>
/// <param name="imageFinder"></param>
/// <param name="imageConverter"></param>
private static void ConvertAssets(ImageFinder imageFinder, IImageConverter imageConverter)
{
var blogAssetsConverter = new BlogAssetConversionJob(imageFinder, imageConverter);
blogAssetsConverter.Convert(@"d:\Projekty\Taurit.Blog\input\assets\img\posts\",
@"d:\Projekty\Taurit.Blog\input\",
@"/assets/img/posts/");
}
public ColorEnhancementTools(IImageConverter converter, IChangeTintAlgorithm changeTintAlgorithm,
IChangeSaturationAlgorithm changeSaturationAlgorithm, IWhiteBalanceAlgorithm whiteBalanceAlgorithm)
{
Converter = converter;
ChangeTintAlgorithm = changeTintAlgorithm;
ChangeSaturationAlgorithm = changeSaturationAlgorithm;
WhiteBalanceAlgorithm = whiteBalanceAlgorithm;
}
private void convert()
{
converter = ImageConverterFactory.CreateImageConverter(_extension);
converter.OnConvertFailed += converter_OnConvertFailed;
converter.OnConvertSucceed += converter_OnConvertSucceed;
converter.OnProgressChanged += converter_OnProgressChanged;
converter.ConvertToImage(_file_path, _save_path, _start_page, _end_page);
}
public Task <Image <Rgba32> > LoadImageAsync(string fileName)
{
string extension = GetExtension(fileName);
IImageConverter converter = this.FindConverter(extension);
return(converter.LoadImageAsync(fileName));
}
public Converter(IMessageReceiver <BusMessage> messageReceiver, IImageConverter imageConverter,
IFileManager fileManager, IDirectoryManager directoryManager)
{
_messageReceiver = messageReceiver ?? throw new ArgumentNullException(nameof(messageReceiver));
_imageConverter = imageConverter ?? throw new ArgumentNullException(nameof(imageConverter));
_fileManager = fileManager ?? throw new ArgumentNullException(nameof(fileManager));
_directoryManager = directoryManager ?? throw new ArgumentNullException(nameof(directoryManager));
_messageReceiver.NewMessageReceived += OnNewMessage;
}
private static void ProcessPartnerMainImages(PartnerModel partner, IImageConverter imageConverter)
{
partner.Image = string.IsNullOrEmpty(partner.Image)
? partner.Image
: Convert.ToBase64String(imageConverter.Convert(Convert.FromBase64String(partner.Image), ImageOptions.Image));
partner.Logo = string.IsNullOrEmpty(partner.Logo)
? partner.Logo
: Convert.ToBase64String(imageConverter.Convert(Convert.FromBase64String(partner.Logo), ImageOptions.Icon));
}
public CameraPageViewModel(IImageProvider imageProvider, IImageConverter imageConverter)
{
converter = imageConverter;
var timer = new Timer(UpdateFpsLabel);
timer.Change(0, 1000);
provider = imageProvider;
provider.NewImage += OnNewImage;
}
public AManager()
{
logger = new ConsoleLogger();
_serializer = new JSONSerializer();
_imageConverter = new MyImageConverter();
responseFactory = new JSONResponseFactory(_serializer);
entityFactory = new EntityFactory();
dataFactory = new DataFactoryDelegation(_serializer, logger, _imageConverter);
}
public UserMigration(IDatabase database, IStoreEvents storeEvent, IImageConverter imageConverter)
{
Contract.Requires <ArgumentNullException>(database != null, "database");
Contract.Requires <ArgumentNullException>(storeEvent != null, "storeEvent");
Contract.Requires <ArgumentNullException>(imageConverter != null, "imageConverter");
_db = database;
_store = storeEvent;
_imageConverter = imageConverter;
_logs = new List <string>();
}
public CmsInitializer(PlatformDataSource platformDataSource, IFileSystemWrapper fileSystemWrapper, IImageConverter imageConverter)
{
this._platformDataSource = platformDataSource;
this._fileSystemWrapper = fileSystemWrapper;
this._imageConverter = imageConverter;
// I must use the service locator here because no implementation for IMembershipService
// could be available.
this._membershipService = DependencyInjector.TryGet <IMembershipService>();
}
public CmsInitializer(PlatformDataSource platformDataSource, IFileSystemWrapper fileSystemWrapper, IImageConverter imageConverter)
{
this._platformDataSource = platformDataSource;
this._fileSystemWrapper = fileSystemWrapper;
this._imageConverter = imageConverter;
// I must use the service locator here because no implementation for IMembershipService
// could be available.
this._membershipService = DependencyInjector.TryGet<IMembershipService>();
}
public CanonRawTests()
{
IServiceCollection services = new ServiceCollection();
ImageLoaderRawSetup.Configure(services);
IServiceProvider serviceProvider = services.BuildServiceProvider();
this._converter = serviceProvider.GetRequiredService <IImageConverter>();
Assert.NotNull(this._converter);
}
public HarrisDetector(IComponentConfiguration componentConfiguration, IImageFactory factory,
IImageConverter imageConverter, ICameraImageConverter cameraImageConverter)
{
cameraConverter = cameraImageConverter;
converter = imageConverter;
imageFactory = factory;
configuration = componentConfiguration;
UpdateDetector();
configuration.ConfigurationChanged += OnConfigurationChanged;
}
public FileProcessor([Named(ConverterType.SVGToPNG)] IImageConverter svgToPNGConverter,
[Named(ConverterType.AIToSVG)] IImageConverter aiToSVGConverter)
{
AssertArgument.IsNotNull(nameof(svgToPNGConverter), svgToPNGConverter);
AssertArgument.IsNotNull(nameof(aiToSVGConverter), aiToSVGConverter);
this.aiToSVGConverter = aiToSVGConverter;
this.svgToPNGConverter = svgToPNGConverter;
SkipSizeIterator = new List <ImageSize> {
new ImageSize(1, 1)
};
}
public PartnersController(IPartnerApplicationService partnerApplicationService,
IAdminQueryApplicationService adminQueryApplicationService,
ICategoryApplicationService сategoryApplicationService,
IGalleryApplicationService galleryService,
IPartnerRatingService ratingService,
IImageConverter imageConverter)
{
_partnerApplicationService = partnerApplicationService;
_adminQueryApplicationService = adminQueryApplicationService;
_categoryApplicationService = сategoryApplicationService;
_galleryService = galleryService;
_ratingService = ratingService;
_imageConverter = imageConverter;
}
public DataFactoryDelegation(ISerializer serializer, ILogger logger, IImageConverter imageConverter)
{
_serializer = serializer;
_logger = logger;
_imageConverter = imageConverter;
if (Neo4JContext.RunTestQuery())
{
_dataFactory = new Neo4JDataFactory(_serializer, _logger, _imageConverter);
}
else
{
_dataFactory = new FileSystemDataFactory(_serializer, _logger, _imageConverter);
}
}
public ImageProcessing(
IImageConverter imageConverter,
IFileInputOutputHelper fileInputOutputHelper,
ILicensePlateAreaDetector licensePlateAreaDetector,
ILicensePlateAreaValidator licensePlateAreaValidator,
ILicensePlateReader licensePlateReader,
ILicensePlateImageBuilder licensePlateImageBuilder)
{
_imageConverter = imageConverter;
_fileInputOutputHelper = fileInputOutputHelper;
_licensePlateAreaDetector = licensePlateAreaDetector;
_licensePlateAreaValidator = licensePlateAreaValidator;
_licensePlateReader = licensePlateReader;
_licensePlateImageBuilder = licensePlateImageBuilder;
}
public AssetController(
ILoggerManager logger,
IBlobService azureBlobService,
IImageAnalyzer azureImageAnalyzer,
IImageConverter azureImageConverter,
IVideoConverter azureVideoConverter,
IAssetRepository assetRepository
)
{
_logger = logger;
_azureBlobService = azureBlobService;
_azureImageAnalyzer = azureImageAnalyzer;
_azureImageConverter = azureImageConverter;
_azureVideoConverter = azureVideoConverter;
_assetRepository = assetRepository;
}
public static IEnumerable <Branch> MapToBranches(PartnerModel partner, IImageConverter imageConverter)
{
if (partner == null)
{
return(new List <Branch>());
}
var branches = new List <Branch>();
ProcessPartnerMainImages(partner, imageConverter);
for (var i = 0; i < partner.Contacts.Count(); i++)
{
var branch = FromPartnerModelToBranch(partner, i);
branches.Add(branch);
}
return(branches);
}
public ImageFileHandler(IMimeProvider mimeProvider, ImageSizeProvider imgSizeProvider, IImageConverter imgCvter)
{
_mimeProvider = mimeProvider;
_imgSizeProvider = imgSizeProvider;
_imgCvter = imgCvter;
var sizes = new List <string>(_imgSizeProvider.Names);
sizes.Insert(0, "raw");
var formats = new List <string>(_mimeProvider.ImageExtensionNames);
formats.Insert(0, "raw");
ModifierDescribe = new ImageModifierDescribe()
{
Sizes = sizes.ToArray(),
Formats = formats.ToArray()
};
}
public ImageDisplayViewModel(IEventAggregator eventAggregator,
IProcessingService processingService,
IStartImageProcessingCommand startImageProcessingCommand,
IStopImageProcessingCommand stopImageProcessingCommand,
ISetOutputImageCommand setOutputImageCommand,
IImageConverter imageConverter)
{
_processingService = processingService;
StartImageProcessingCommand = startImageProcessingCommand;
StopImageProcessingCommand = stopImageProcessingCommand;
SetOutputImageCommand = setOutputImageCommand;
StartImageProcessingCommand.OnProcessingStop = () => { OnPropertyChanged(string.Empty); };
StopImageProcessingCommand.OnProcessingStop = () => { OnPropertyChanged(string.Empty); };
SetOutputImageCommand.OnImageUpdate = SetOutputImage;
eventAggregator.GetEvent <ShouldUpdateProcessingEngineEvent>().Subscribe(UpdateProcessingEngine);
}
public FaceBook(IVideoConverter VideoConverter, IImageConverter ImageConverter)//,IConfiguration configuration)
{
_VideoConverter = VideoConverter;
_ImageConverter = ImageConverter;
// _configuration = configuration;
// /////
//// we can get this data from API or Database
_imageRequiredScaled.Add(new ImageInfo {
Extention = ImageFormat.Png, Width = 64, Height = 64, FoldersName = "Small/Thumbnail"
});
_imageRequiredScaled.Add(new ImageInfo {
Extention = ImageFormat.Png, Width = 256, Height = 256, FoldersName = "Medium/Personal/Folder 1"
});
// {
// new VideoInfo { Extention = VideoFormat.mp4, Quality = VideoQuality.Q320 },
// new VideoInfo { Extention = VideoFormat.mp4, Quality = VideoQuality.QFullHD },
// new VideoInfo { Extention = VideoFormat.mp4, Quality = VideoQuality.Q4K },
//};
}
/// <summary>
/// The actual factory method which returns the correct implementation of the image converter
/// based on the first bytes in the input stream.
/// </summary>
/// <param name="stream">The input stream</param>
/// <returns>Interface abstracting the different implementations of the image converter</returns>
public static IImageConverter GetImageConverter(Stream stream)
{
IImageConverter result = null;
var pngImageConverter = new PngImageConverter(stream);
if (pngImageConverter.IsSupportedFormat())
{
result = pngImageConverter;
}
var gifImageConverter = new GifImageConverter(stream);
if (gifImageConverter.IsSupportedFormat())
{
result = gifImageConverter;
}
return(result);
}
public ConversionProgress(ImageFiles images, bool changeFormat, ImageFormat convertTo, int quality, bool changeSize, int size, bool resizeSmaller, bool overwrite, string outputPath)
{
_images = images;
_outputPath = outputPath;
_statusText = new StringBuilder();
_cancelCommand = new RelayCommand(param => Cancel());
_openFolderCommand = new RelayCommand(param => OpenFolder());
_log = new FileLog();
if (changeSize)
{
_sizeConverter = new ImageSizeConverter(size, resizeSmaller);
}
if (changeFormat && convertTo.Equals(ImageFormat.Jpeg))
{
_storage = new JpgImageStorage(outputPath, quality, overwrite);
}
else
{
_storage = new DefaultImageStorage(outputPath, changeFormat ? convertTo : null, overwrite);
}
}
public PostService(
IPostRepository postRepository,
IAccountRepository accountRepository,
ICommentRepository commentRepository,
IImageConverter imageConverter,
IFileService fileService,
ICurrentUtcDateProvider currentUtcDateProvider,
IMapper mapper,
IOptionsMonitor <PostOptions> postOptions,
ILogger <PostService> logger)
{
this.postRepository = postRepository;
this.accountRepository = accountRepository;
this.commentRepository = commentRepository;
this.imageConverter = imageConverter;
this.fileService = fileService;
this.currentUtcDateProvider = currentUtcDateProvider;
this.mapper = mapper;
this.postOptions = postOptions;
this.logger = logger;
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
e.Cancel = true;
if (_thread.ThreadState == ThreadState.Running)
{
DialogResult dr = MessageBox.Show("确定取消文档转换吗?", "取消转换", MessageBoxButtons.OKCancel);
if (dr == DialogResult.OK)//如果点击“确定”按钮
{
converter.Cancel();
btn_convert.Enabled = true;
progressBar1.Value = 0;
}
}
else if (MessageBox.Show("确认退出吗？", "系统提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.OK)
{
_thread = null;
converter = null;
e.Cancel = false;
}
}
public FileService(IPlatformDataSource dataSource, IFileManager fileManager, IImageConverter imageConverter)
{
this._dataSource = dataSource;
this._fileManager = fileManager;
this._imageConverter = imageConverter;
}
public ImageMapper(IImageConverter imageConverter)
{
this._imageConverter = imageConverter;
}
public FileManager(IPlatformDataSource dataSource, IImageConverter imageConverter)
{
this._dataSource = dataSource;
this._imageConverter = imageConverter;
}
public FileController(IFileService fileService, IImageConverter imageConverter)
{
this._fileService = fileService;
this._imageConverter = imageConverter;
}
private static void ConfigureFileMaps(IImageConverter imageConverter)
{
// Map a file to a base64 string if available.
var fileConfig = new MapConfig<object, object>();
fileConfig.AfterMapAction = (content, model) =>
{
var fileProperties = model.GetType().GetProperties().Where(pr => pr.GetCustomAttributes(typeof(ImageAttribute), true).Any());
foreach (var fileProperty in fileProperties)
{
var file = model.GetPropertyValue(fileProperty.Name) as FileDisplayModel;
var attribute = fileProperty.GetAttribute<ImageAttribute>();
var sizeX = string.IsNullOrWhiteSpace(attribute.WidthProperty) ? attribute.Width : (int)model.GetPropertyValue(attribute.WidthProperty);
var sizeY = string.IsNullOrWhiteSpace(attribute.HeightProperty) ? attribute.Height : (int)model.GetPropertyValue(attribute.HeightProperty);
string path = null;
if (file != null && file.Folder != null)
{
var imagePath = string.Format("{0}.{1}", System.IO.Path.Combine(file.Folder, file.Path, file.FileName), file.Extension);
path = imageConverter.ImageAsPath(imagePath, sizeX, sizeY, attribute.KeepAspectRatio);
}
if (model.HasProperty(fileProperty.Name + "Path"))
{
model.SetPropertyValue(fileProperty.Name + "Path", path);
}
}
};
DataMapper.RegisterMapConfig(fileConfig);
}
