====== Source Code WpfDesktopEditionSample MultipleJpeg2000RasterLayer_08_30_2016.zip ====== ====App.xaml.cs====

using System;  
 using System.Collections.Generic;  
 using System.Configuration;  
 using System.Data;  
 using System.Linq;  
 using System.Windows;  
  
 namespace SelectAndDragFeature  
 {  
     ///   
     /// Interaction logic for App.xaml  
     ///   
     public partial class App : Application  
     {  
     }  
 }

====MainWindow.xaml.cs====


using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Forms;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.WpfDesktopEdition;

namespace MultipleJpeg2000RasterLayerSample
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void btnLoad_Click(object sender, RoutedEventArgs e)
        {
            string directory = txtFolder.Text;
            if (!Directory.Exists(directory))
            {
                return;
            }

            // Gets the files path.
            var filesPath = Directory.GetFiles(directory).TakeWhile(filePath => { return Path.GetExtension(filePath).ToLowerInvariant().Equals(".jp2"); });
            // Instantiates MultipleJpeg2000RasterLayer with the files path.
            var layer = new MultipleJpeg2000RasterLayer(filesPath);

            // Adds the MultipleJpeg2000RasterLayer into the map.
            var overlay = new LayerOverlay();
            overlay.Layers.Add(layer);
            wpfMap.Overlays.Add(overlay);

            layer.Open();
            wpfMap.MapUnit = GeographyUnit.Meter;
            wpfMap.CurrentExtent = layer.GetBoundingBox();

            wpfMap.Refresh();
        }

        private void btnSelectFolder_Click(object sender, RoutedEventArgs e)
        {
            FolderBrowserDialog fbd = new FolderBrowserDialog();
            if (fbd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                txtFolder.Text = fbd.SelectedPath;
                btnLoad.IsEnabled = true;
            }
        }
    }
}

====MultipleJpeg2000RasterLayer.cs====


using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace ThinkGeo.MapSuite.Core
{
    public class MultipleJpeg2000RasterLayer : Layer
    {
        private Collection featureLayers;

        public override bool HasBoundingBox
        {
            get
            {
                return true;
            }
        }

        public MultipleJpeg2000RasterLayer()
        {
            featureLayers = new Collection();
        }

        public MultipleJpeg2000RasterLayer(IEnumerable imagePathFilenames)
        {
            featureLayers = new Collection();
            foreach (var imagePathFilename in imagePathFilenames)
            {
                featureLayers.Add(new Jpeg2000RasterLayer(imagePathFilename));
            }
        }

        public MultipleJpeg2000RasterLayer(IEnumerable imagePathFilenames, IEnumerable worldfilePathFilenames)
        {
            featureLayers = new Collection();
            for (int i = 0; i < imagePathFilenames.Count(); i++)
            {
                featureLayers.Add(new Jpeg2000RasterLayer(imagePathFilenames.ElementAt(i), worldfilePathFilenames.ElementAt(i)));
            }
        }

        public MultipleJpeg2000RasterLayer(IEnumerable imagePathFilenames, IEnumerable imageExtents)
        {
            featureLayers = new Collection();
            for (int i = 0; i < imagePathFilenames.Count(); i++)
            {
                featureLayers.Add(new Jpeg2000RasterLayer(imagePathFilenames.ElementAt(i), imageExtents.ElementAt(i)));
            }

        }

        protected override void DrawCore(GeoCanvas canvas, Collection labelsInAllLayers)
        {
            foreach (var featureLayer in featureLayers)
            {
                featureLayer.Draw(canvas, labelsInAllLayers);
            }
        }

        protected override void OpenCore()
        {
            foreach (var featureLayer in featureLayers)
            {
                featureLayer.Open();
            }
        }

        protected override bool IsOpenCore
        {
            get
            {
                base.IsOpenCore = true;
                foreach (var featureLayer in featureLayers)
                {
                    if (!featureLayer.IsOpen) { base.IsOpenCore = false; }
                }
                return base.IsOpenCore;
            }

            set
            {
                base.IsOpenCore = value;
            }
        }

        protected override void CloseCore()
        {
            if (IsOpen)
            {
                foreach (var featureLayer in featureLayers)
                {
                    featureLayer.Close();
                }
            }
        }

        protected override Layer CloneDeepCore()
        {
            MultipleJpeg2000RasterLayer newLayer = new MultipleJpeg2000RasterLayer();
            foreach (var featureLayer in featureLayers)
            {
                newLayer.featureLayers.Add(featureLayer.CloneDeep() as Jpeg2000RasterLayer);
            }
            return newLayer;
        }

        protected override RectangleShape GetBoundingBoxCore()
        {
            RectangleShape boundingBox = null;
            foreach (var featureLayer in featureLayers)
            {
                if (boundingBox == null)
                {
                    boundingBox = featureLayer.GetBoundingBox();
                }
                else
                {
                    boundingBox.ExpandToInclude(featureLayer.GetBoundingBox());
                }
            }

            return boundingBox;
        }
    }
}