eit-team / mesher Goto Github PK

CGAL based FEMs for EIT from segmentation files

License: BSD 3-Clause "New" or "Revised" License

C++ 90.70% CMake 1.93% MATLAB 7.11% Dockerfile 0.26%

electrical-impedance-tomography meshing cgal segmentation meshes

mesher's Introduction

EIT-Mesher

EIT-MESHER is C++ software, based on the CGAL library, which generates high quality Finite Element Model tetrahedral meshes from binary masks of 3D volume segmentations. Originally developed for biomedical applications in Electrical Impedance Tomography (EIT) to address the need for custom, non-linear refinement in certain areas (e.g. around electrodes), EIT-MESHER can also be used in other fields where custom FEM refinement is required, such as Diffuse Optical Tomography (DOT).

Example Usage
Unit Cube - 'Hello World' example
Meshing segmented brain data
Meshing from STL file
Mesh refinement examples
Mesh deformation

Citing this work

If you use this repository please cite the accompanying JORS article

Dowrick, T., Avery, J., Faulkner, M., Holder, D. and Aristovich, K., 2020. EIT-MESHER – Segmented FEM Mesh Generation and Refinement. Journal of Open Research Software, 8(1), p.27. DOI: http://doi.org/10.5334/jors.321

Using the Meshes

Examples for using the EIT-MESHER outputs with common EIT and DOT solvers are given in solvers examples

Build instructions (tested on Ubuntu 16, 17, 18 and WSL 1&2)

Install dependencies

sudo apt-get install build-essential cmake libcgal-dev libcgal-qt5-dev libglu1-mesa libxi-dev libxmu-dev libglu1-mesa-dev

Clone repository

git clone https://github.com/EIT-team/Mesher.git

Make build & output directories

cd Mesher
mkdir build
mkdir output

Compile

cd build
cmake ..
make

Test

cd ../test/
./run_tests

Run mesher ( from /Mesher root directory)

Usage:
./bin/mesher -i INPUT_INR -e INPUT_ELECTRODES -p INPUT_PARAMETERS
        -i input image file
        -e electrode position file
        -p parameter file
        -o output mesh name (default = new_mesh)
        -d output directory (default = output/)

Example:

./bin/mesher -i inputs/input.inr -e inputs/Electrodes.txt -p inputs/params.txt

Produces the following mesh as viewed in paraview

Docker instructions (for Ubuntu 19&20+, macOS)

EIT-MESHER can be built in a container to install on newer Linux installations. Windows users require WSL2 for docker to work.

Install container

The docker container can be obtained using two different methods:

Build container from source (mesher is a name of your choice):

docker build -t mesher .

Pull image directly from dockerhub without having to build, renaming the container to mesher (or name of your choice) :

docker pull doctorjimbles/eit-mesher
docker image tag doctorjimbles/eit-mesher:latest mesher:latest

Running Mesher from container

To test if it is working run the container with no inputs, this will call the mesher with defaults which runs the single example included in the container:

docker run --rm mesher

The --rm flag removes the container after its done to prevent having lots of unnecessary container IDs.

The mesher can then be called with the parameter arguments as normal Note these are files inside the container.

docker run --rm mesher -i inputs/input.inr -e inputs/Electrodes.txt -p inputs/params.txt

Using your own data - mounting volumes

The container has two root directories /in and /out which can be mounted as volumes to map to directories on the host using the -v flag. So for example, if we had the MESHER repository in our home dir we would add the flags:

 -v ~/Mesher/inputs:/in -v ~/Mesher/output:/out

The mesher can then finally be called by combining the volume definitions and then directing the mesher at the new input location /in/. Note Parameters given must be with respect to the container file structure. So for example, to make the default mesh but using the inputs files in the repository on the host machine (assuming it is stored in /home/user/Mesher):

docker run --rm  -v ~/Mesher/inputs:/in -v ~/Mesher/output:/out  mesher -i /in/input.inr -e /in/Electrodes.txt -p /in/params.txt -d /out/ -o dockertest

This will result in an output mesh dockertest in /home/user/Mesher/output.

To run the NN scalp example (still assuming this repository is stored in /home/user/Mesher)

docker run --rm  -v ~/Mesher/examples/neonatescalp/:/in -v ~/Mesher/examples/neonatescalp/output:/out  mesher -i /in/NNscalp.inr -e /in/NNscalp_elecINRpos.txt -p /in/NNscalp_param.txt -d /out/ -o dockertestNN

Improving slow file write on some systems

In some systems (reported on macOS 10.15.6, Docker Desktop 2.3.0.4, Docker Engine 19.03.12) it is much slower writing files into the mapped volume. Therefore to improve performance, it is possible to call the mesher and copy the files out afterwards. To do this we remove the --rm flag as we want to keep it, and add the --name flag to give it a name that makes more sense to us. We also drop the -v flag for the \out folder.

docker run --name NNmesher  -v ~/Mesher/examples/neonatescalp/:/in mesher -i /in/NNscalp.inr -e /in/NNscalp_elecINRpos.txt -p /in/NNscalp_param.txt -d /out/ -o dockertestNN

The mesher files can then be copied outside of the container

docker cp NNmesher:/out ./newoutputdir

mesher's People

Contributors

Stargazers

Watchers

Forkers

keydawg carlpan937 xtong5 maybelaterornot

mesher's Issues

Test if mesh refinement is in correct place

e.g. we want a sphere at 1,1,1, check if it is there

installing on old workstation

Install CGAL

sudo apt-get install libcgal-dev

Install CUDA drivers (I think)

sudo apt-get install libglu1-mesa libxi-dev libxmu-dev libglu1-mesa-dev

Make inputs all mm, outputs m

Makes sense for electrode positions to be in mm

options["sphere_radius"];
  options["sphere_centre_x"];
  options["sphere_centre_y"];
  options["sphere_centre_z"];
  options["sphere_cell_size"];
  options["cuboid_x_extent"];
  options["cuboid_y_extent"];
  options["cuboid_z_extent"];
  options["cuboid_centre_x"];
  options["cuboid_centre_y"];
  options["cuboid_centre_z"];
  options["cuboid_cell_size"];

should be in mm

PEITS needs metres, so all outputs in metres

Check if input files and output directory

Currently, no checking is done to make sure that the inputs/outputs are sensible, so a segfault occurs if an invalid path is given.

User specified depth refinement point

Currently depth refinement is based on origin/centre of the input inr file, which is of limited use. Better to give option of setting this point. Relevant part in sizing_fields.cpp

  ub_x = origin.x();
  ub_y = origin.y();
  ub_z = origin.z();

Make Kirill's Mesher work in Linux

At the moment it only works in Windows. It also needs some refactoring.

Spherical refinement interacts weirdly with depth refinement

Spherical refinement with depth refinement turned off still appeared to use cell_fine_size_mm which should only be used if depth or planar refinement turned on. Likely a mistake in the switch case

Compile error in Ubuntu 18.04

Fresh install of Ubuntu 18.04 on virtual machine, gives a following error when trying to build Mesher

#[  5%] Building CXX object src/CMakeFiles/mesher.dir/Mesher_plus.cpp.o
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h: In instantiation of ‘bool CGAL::write_c3t3_to_vtk_xml_file(const C3t3&, const string&) [with C3t3 = C3t3_EIT; std::__cxx11::string = std::__cxx11::basic_string<char>]’:
/home/james/Mesher/src/Mesher_plus.cpp:282:69:   required from here
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:64:14: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             V[it->point()] = i;
             ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:93:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v0->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:94:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v1->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:95:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v2->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:96:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v3->point()] << std::endl;
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
src/CMakeFiles/mesher.dir/build.make:62: recipe for target 'src/CMakeFiles/mesher.dir/Mesher_plus.cpp.o' failed
make[2]: *** [src/CMakeFiles/mesher.dir/Mesher_plus.cpp.o] Error 1
CMakeFiles/Makefile2:85: recipe for target 'src/CMakeFiles/mesher.dir/all' failed
make[1]: *** [src/CMakeFiles/mesher.dir/all] Error 2
Makefile:94: recipe for target 'all' failed
make: *** [all] Error 2
james@james-VirtualBox:~/Mesher/build$ make < out.log
bash: out.log: No such file or directory
james@james-VirtualBox:~/Mesher/build$ make > out.log
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h: In instantiation of ‘bool CGAL::write_c3t3_to_vtk_xml_file(const C3t3&, const string&) [with C3t3 = C3t3_EIT; std::__cxx11::string = std::__cxx11::basic_string<char>]’:
/home/james/Mesher/src/Mesher_plus.cpp:282:69:   required from here
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:64:14: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             V[it->point()] = i;
             ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:93:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v0->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:94:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v1->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:95:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v2->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:96:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v3->point()] << std::endl;
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
make[2]: *** [src/CMakeFiles/mesher.dir/Mesher_plus.cpp.o] Error 1
make[1]: *** [src/CMakeFiles/mesher.dir/all] Error 2
make: *** [all] Error 2
james@james-VirtualBox:~/Mesher/build$ gedit out.log
james@james-VirtualBox:~/Mesher/build$ make | tee out.log
[  5%] Building CXX object src/CMakeFiles/mesher.dir/Mesher_plus.cpp.o
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h: In instantiation of ‘bool CGAL::write_c3t3_to_vtk_xml_file(const C3t3&, const string&) [with C3t3 = C3t3_EIT; std::__cxx11::string = std::__cxx11::basic_string<char>]’:
/home/james/Mesher/src/Mesher_plus.cpp:282:69:   required from here
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:64:14: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             V[it->point()] = i;
             ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:93:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v0->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:94:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v1->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:95:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v2->point()] << " ";
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
In file included from /home/james/Mesher/src/Mesher_plus.cpp:10:0:
/home/james/Mesher/src/write_c3t3_to_vtk_xml_file.h:96:26: error: no match for ‘operator[]’ (operand types are ‘std::map<CGAL::Point_3<CGAL::Epick>, int>’ and ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’)
             vtk_file << V[v3->point()] << std::endl;
                         ~^
In file included from /usr/include/c++/7/map:61:0,
                 from /usr/include/CGAL/Profile_counter.h:58,
                 from /usr/include/CGAL/Uncertain.h:26,
                 from /usr/include/CGAL/assertions.h:353,
                 from /usr/include/CGAL/basic.h:42,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:28,
                 from /usr/include/CGAL/Simple_cartesian.h:28,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:28,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Mesher_plus.cpp:2:
/usr/include/c++/7/bits/stl_map.h:484:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](const key_type& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:484:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘const key_type& {aka const CGAL::Point_3<CGAL::Epick>&}’
/usr/include/c++/7/bits/stl_map.h:504:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = CGAL::Point_3<CGAL::Epick>; _Tp = int; _Compare = std::less<CGAL::Point_3<CGAL::Epick> >; _Alloc = std::allocator<std::pair<const CGAL::Point_3<CGAL::Epick>, int> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = int; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = CGAL::Point_3<CGAL::Epick>]
       operator[](key_type&& __k)
       ^~~~~~~~
/usr/include/c++/7/bits/stl_map.h:504:7: note:   no known conversion for argument 1 from ‘CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<CGAL::Triangulation_data_structure_3<CGAL::Mesh_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, CGAL::Regular_triangulation_vertex_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Triangulation_ds_vertex_base_3<void> > >, CGAL::Compact_mesh_cell_base_3<CGAL::Robust_weighted_circumcenter_filtered_traits_3<CGAL::Epick>, CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3, CGAL::Epick>, void>, CGAL::Sequential_tag> > >::Point {aka CGAL::Weighted_point_3<CGAL::Epick>}’ to ‘std::map<CGAL::Point_3<CGAL::Epick>, int>::key_type&& {aka CGAL::Point_3<CGAL::Epick>&&}’
make[2]: *** [src/CMakeFiles/mesher.dir/Mesher_plus.cpp.o] Error 1
src/CMakeFiles/mesher.dir/build.make:62: recipe for target 'src/CMakeFiles/mesher.dir/Mesher_plus.cpp.o' failed
make[1]: *** [src/CMakeFiles/mesher.dir/all] Error 2
CMakeFiles/Makefile2:85: recipe for target 'src/CMakeFiles/mesher.dir/all' failed
make: *** [all] Error 2
Makefile:94: recipe for target 'all' failed

This is with version 4.11-2build2 of cgallib-dev , where confirmed working version on Ubuntu 16.04 is 4.7-4

add to dependencies

build-essential package also required

Take polyhedral sufaces as inputs

Currently the Mesher reads in .inr files to create the domains. However for some applications such as meshing files from CAD, it would be better to accept surfaces instead. CGAL can read .off files, like in example 3.3.1 here

Print number of elements to stdout

Odd behaviour with empty electrodes file

Unit Cube example has empty electrode file, but .electrodes file returns an electrode position that is seemingly random. This might mean that areas of the mesh are refined accidentally. If you can disable the electrode refinement then this would prevent this causing problems

Add CGAL install instructions for Linux

Licenses

need license file for the mesher and StlTools

Allow for output filename to be specified

Filename is currently hardcoded in the save_matlab function (lines 96-98)

  //! Open the file and put the array in
  pmat = matOpen("Mesh.mat", "w");
  matPutVariable(pmat, "Nodes", mVtx);

Load sizing field from file

Sizing field specified at each voxel in inr file would make it much easier to implement new types of refinement, without having to code them into the mesher

Investigate on making this code parallel with CGAL's last version

CGAL's last version allows parallel programming and the Mesher's code could benefit from this.

Code coverage report

Correctly adding location of 'mat.h'

The matlab_save.h code needs to include the matlab file mat.h, but this isn't necessarily installed in a consistent location on the system.

typing 'matlabroot' in a MATLAB prompt will give the root MATLAB installation path, and mat.h should be located in matlabroot /extern/include/

Does not compile on Ubuntu 20.04

Tested on Ubuntu 20.04 WSL2

Looks like some changes to the template classes and something have been deprecated - almost certainly related to the breaking changes listed here

warning: ‘template<class Image, class BGT, class Image_word_type_, class Subdomain_index, class Null_subdomain_index, class Wrapper_> class CGAL::Labeled_image_mesh_domain_3’ is deprecated: The class template `CGAL::Labeled_image_mesh_domain_3` is now deprecated. Use the static member function template `Labeled_mesh_domain_3<K>::create_labeled_image_mesh_domain` instead.

It might be possible to set some compiler flags ‘-std=c++14’ and ‘-std=c++17’ as mentioned in the cmake output:

[  5%] Building CXX object src/CMakeFiles/mesher.dir/Sizing_fields.cpp.o
In file included from /usr/include/CGAL/Kernel/global_functions.h:25,
                 from /usr/include/CGAL/Cartesian/Cartesian_base.h:22,
                 from /usr/include/CGAL/Simple_cartesian.h:20,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:20,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Sizing_fields.h:4,
                 from /home/james/Mesher/src/Sizing_fields.cpp:4:
/usr/include/CGAL/Kernel/hash_functions.h:25:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
   25 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:47:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
   47 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:57:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
   57 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:66:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
   66 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:75:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
   75 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:84:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
   84 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:93:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
   93 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:102:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  102 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:126:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  126 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:135:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  135 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:145:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  145 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:154:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  154 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:164:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  164 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
/usr/include/CGAL/Kernel/hash_functions.h:174:13: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  174 | inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
      |             ^~~~~~~~~~~
      |             enable_if
In file included from /usr/include/CGAL/Lazy_exact_nt.h:33,
                 from /usr/include/CGAL/internal/Exact_type_selector.h:25,
                 from /usr/include/CGAL/Exact_kernel_selector.h:26,
                 from /usr/include/CGAL/Filtered_kernel.h:22,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:21,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Sizing_fields.h:4,
                 from /home/james/Mesher/src/Sizing_fields.cpp:4:
/usr/include/CGAL/Lazy.h:108:30: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  108 | template<class T>inline std::enable_if_t<std::is_arithmetic<T>::value||std::is_enum<T>::value, T> approx(T d){return d;}
      |                              ^~~~~~~~~~~
      |                              enable_if
/usr/include/CGAL/Lazy.h:109:30: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  109 | template<class T>inline std::enable_if_t<std::is_arithmetic<T>::value||std::is_enum<T>::value, T> exact (T d){return d;}
      |                              ^~~~~~~~~~~
      |                              enable_if
/usr/include/CGAL/Lazy.h:110:30: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  110 | template<class T>inline std::enable_if_t<std::is_arithmetic<T>::value||std::is_enum<T>::value, unsigned> depth(T){return 0;}
      |                              ^~~~~~~~~~~
      |                              enable_if
/usr/include/CGAL/Lazy.h:113:30: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  113 | template<class T>inline std::enable_if_t<std::is_empty<T>::value, T> exact(T){return {};}
      |                              ^~~~~~~~~~~
      |                              enable_if
/usr/include/CGAL/Lazy.h:114:30: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  114 | template<class T>inline std::enable_if_t<std::is_empty<T>::value, T> approx(T){return {};}
      |                              ^~~~~~~~~~~
      |                              enable_if
/usr/include/CGAL/Lazy.h:115:30: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  115 | template<class T>inline std::enable_if_t<std::is_empty<T>::value, unsigned> depth(T){return 0;}
      |                              ^~~~~~~~~~~
      |                              enable_if
/usr/include/CGAL/Lazy.h:118:31: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  118 | template <class T, class=std::enable_if_t<is_iterator_type<T,std::input_iterator_tag>::value>>
      |                               ^~~~~~~~~~~
      |                               enable_if
/usr/include/CGAL/Lazy.h:118:42: error: expected ‘>’ before ‘<’ token
  118 | template <class T, class=std::enable_if_t<is_iterator_type<T,std::input_iterator_tag>::value>>
      |                                          ^
/usr/include/CGAL/Lazy.h:119:1: error: ‘exact’ function uses ‘auto’ type specifier without trailing return type
  119 | auto exact(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::exact(u);});}
      | ^~~~
/usr/include/CGAL/Lazy.h:119:1: note: deduced return type only available with ‘-std=c++14’ or ‘-std=gnu++14’
/usr/include/CGAL/Lazy.h: In function ‘auto CGAL::exact(const T&)’:
/usr/include/CGAL/Lazy.h:119:64: error: use of ‘auto’ in lambda parameter declaration only available with ‘-std=c++14’ or ‘-std=gnu++14’
  119 | auto exact(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::exact(u);});}
      |                                                                ^~~~
/usr/include/CGAL/Lazy.h: In lambda function:
/usr/include/CGAL/Lazy.h:119:98: error: no matching function for call to ‘exact(const int&)’
  119 | auto exact(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::exact(u);});}
      |                                                                                                  ^
/usr/include/CGAL/Lazy.h:84:1: note: candidate: ‘template<class AT, class ET, class E2A> const ET& CGAL::exact(const CGAL::Lazy<AT, ET, E2A>&)’
   84 | exact(const Lazy<AT,ET,E2A>& l)
      | ^~~~~
/usr/include/CGAL/Lazy.h:84:1: note:   template argument deduction/substitution failed:
/usr/include/CGAL/Lazy.h:119:98: note:   mismatched types ‘const CGAL::Lazy<AT, ET, E2A>’ and ‘const int’
  119 | auto exact(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::exact(u);});}
      |                                                                                                  ^
/usr/include/CGAL/Lazy.h:104:1: note: candidate: ‘const CGAL::Bbox_2& CGAL::exact(const CGAL::Bbox_2&)’
  104 | CGAL_LAZY_FORWARD(Bbox_2)
      | ^~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:104:1: note:   no known conversion for argument 1 from ‘const int’ to ‘const CGAL::Bbox_2&’
  104 | CGAL_LAZY_FORWARD(Bbox_2)
      | ^~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:105:1: note: candidate: ‘const CGAL::Bbox_3& CGAL::exact(const CGAL::Bbox_3&)’
  105 | CGAL_LAZY_FORWARD(Bbox_3)
      | ^~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:105:1: note:   no known conversion for argument 1 from ‘const int’ to ‘const CGAL::Bbox_3&’
  105 | CGAL_LAZY_FORWARD(Bbox_3)
      | ^~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:119:6: note: candidate: ‘template<class T, class> auto CGAL::exact(const T&)’
  119 | auto exact(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::exact(u);});}
      |      ^~~~~
/usr/include/CGAL/Lazy.h:119:6: note:   template argument deduction/substitution failed:
/usr/include/CGAL/Lazy.h: At global scope:
/usr/include/CGAL/Lazy.h:120:31: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  120 | template <class T, class=std::enable_if_t<is_iterator_type<T,std::input_iterator_tag>::value>>
      |                               ^~~~~~~~~~~
      |                               enable_if
/usr/include/CGAL/Lazy.h:120:42: error: expected ‘>’ before ‘<’ token
  120 | template <class T, class=std::enable_if_t<is_iterator_type<T,std::input_iterator_tag>::value>>
      |                                          ^
/usr/include/CGAL/Lazy.h:121:1: error: ‘approx’ function uses ‘auto’ type specifier without trailing return type
  121 | auto approx(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::approx(u);});}
      | ^~~~
/usr/include/CGAL/Lazy.h:121:1: note: deduced return type only available with ‘-std=c++14’ or ‘-std=gnu++14’
/usr/include/CGAL/Lazy.h: In function ‘auto CGAL::approx(const T&)’:
/usr/include/CGAL/Lazy.h:121:65: error: use of ‘auto’ in lambda parameter declaration only available with ‘-std=c++14’ or ‘-std=gnu++14’
  121 | auto approx(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::approx(u);});}
      |                                                                 ^~~~
/usr/include/CGAL/Lazy.h: In lambda function:
/usr/include/CGAL/Lazy.h:121:100: error: no matching function for call to ‘approx(const int&)’
  121 | auto approx(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::approx(u);});}
      |                                                                                                    ^
/usr/include/CGAL/Lazy.h:66:1: note: candidate: ‘template<class AT, class ET, class E2A> const AT& CGAL::approx(const CGAL::Lazy<AT, ET, E2A>&)’
   66 | approx(const Lazy<AT,ET,E2A>& l)
      | ^~~~~~
/usr/include/CGAL/Lazy.h:66:1: note:   template argument deduction/substitution failed:
/usr/include/CGAL/Lazy.h:121:100: note:   mismatched types ‘const CGAL::Lazy<AT, ET, E2A>’ and ‘const int’
  121 | auto approx(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::approx(u);});}
      |                                                                                                    ^
/usr/include/CGAL/Lazy.h:75:1: note: candidate: ‘template<class AT, class ET, class E2A> AT& CGAL::approx(CGAL::Lazy<AT, ET, E2A>&)’
   75 | approx(Lazy<AT,ET,E2A>& l)
      | ^~~~~~
/usr/include/CGAL/Lazy.h:75:1: note:   template argument deduction/substitution failed:
/usr/include/CGAL/Lazy.h:121:100: note:   mismatched types ‘CGAL::Lazy<AT, ET, E2A>’ and ‘const int’
  121 | auto approx(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::approx(u);});}
      |                                                                                                    ^
/usr/include/CGAL/Lazy.h:104:1: note: candidate: ‘const CGAL::Bbox_2& CGAL::approx(const CGAL::Bbox_2&)’
  104 | CGAL_LAZY_FORWARD(Bbox_2)
      | ^~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:104:1: note:   no known conversion for argument 1 from ‘const int’ to ‘const CGAL::Bbox_2&’
  104 | CGAL_LAZY_FORWARD(Bbox_2)
      | ^~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:105:1: note: candidate: ‘const CGAL::Bbox_3& CGAL::approx(const CGAL::Bbox_3&)’
  105 | CGAL_LAZY_FORWARD(Bbox_3)
      | ^~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:105:1: note:   no known conversion for argument 1 from ‘const int’ to ‘const CGAL::Bbox_3&’
  105 | CGAL_LAZY_FORWARD(Bbox_3)
      | ^~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:121:6: note: candidate: ‘template<class T, class> auto CGAL::approx(const T&)’
  121 | auto approx(T const& t) {return make_transforming_iterator(t,[](auto const&u){return CGAL::approx(u);});}
      |      ^~~~~~
/usr/include/CGAL/Lazy.h:121:6: note:   template argument deduction/substitution failed:
/usr/include/CGAL/Lazy.h: At global scope:
/usr/include/CGAL/Lazy.h:122:31: error: ‘enable_if_t’ in namespace ‘std’ does not name a template type; did you mean ‘enable_if’?
  122 | template <class T, class=std::enable_if_t<is_iterator_type<T,std::input_iterator_tag>::value>>
      |                               ^~~~~~~~~~~
      |                               enable_if
/usr/include/CGAL/Lazy.h:122:42: error: expected ‘>’ before ‘<’ token
  122 | template <class T, class=std::enable_if_t<is_iterator_type<T,std::input_iterator_tag>::value>>
      |                                          ^
In file included from /usr/include/CGAL/Lazy_exact_nt.h:33,
                 from /usr/include/CGAL/internal/Exact_type_selector.h:25,
                 from /usr/include/CGAL/Exact_kernel_selector.h:26,
                 from /usr/include/CGAL/Filtered_kernel.h:22,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:21,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Sizing_fields.h:4,
                 from /home/james/Mesher/src/Sizing_fields.cpp:4:
/usr/include/CGAL/Lazy.h:320:33: error: ‘std::index_sequence’ has not been declared
  320 |   void update_exact_helper(std::index_sequence<I...>) const {
      |                                 ^~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:320:47: error: expected ‘,’ or ‘...’ before ‘<’ token
  320 |   void update_exact_helper(std::index_sequence<I...>) const {
      |                                               ^
/usr/include/CGAL/Lazy.h: In member function ‘void CGAL::Lazy_rep_n<AT, ET, AC, EC, E2A, L>::update_exact() const’:
/usr/include/CGAL/Lazy.h:327:30: error: ‘make_index_sequence’ is not a member of ‘std’
  327 |     update_exact_helper(std::make_index_sequence<sizeof...(L)>{});
      |                              ^~~~~~~~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:327:63: error: expected primary-expression before ‘{’ token
  327 |     update_exact_helper(std::make_index_sequence<sizeof...(L)>{});
      |                                                               ^
/usr/include/CGAL/Lazy.h: At global scope:
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:39: error: ‘remove_reference_t’ is not a member of ‘std’; did you mean ‘remove_reference’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                       ^~~~~~~~~~~~~~~~~~
      |                                       remove_reference
/usr/include/CGAL/Lazy.h:831:89: error: template argument 1 is invalid
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                                                                         ^~
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:39: error: ‘remove_reference_t’ is not a member of ‘std’; did you mean ‘remove_reference’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                       ^~~~~~~~~~~~~~~~~~
      |                                       remove_reference
/usr/include/CGAL/Lazy.h:831:89: error: template argument 1 is invalid
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                                                                         ^~
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:39: error: ‘remove_reference_t’ is not a member of ‘std’; did you mean ‘remove_reference’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                       ^~~~~~~~~~~~~~~~~~
      |                                       remove_reference
/usr/include/CGAL/Lazy.h:831:89: error: template argument 1 is invalid
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                                                                         ^~
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:39: error: ‘remove_reference_t’ is not a member of ‘std’; did you mean ‘remove_reference’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                       ^~~~~~~~~~~~~~~~~~
      |                                       remove_reference
/usr/include/CGAL/Lazy.h:831:89: error: template argument 1 is invalid
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                                                                         ^~
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:22: error: ‘remove_cv_t’ is not a member of ‘std’; did you mean ‘remove_cv’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                      ^~~~~~~~~~~
      |                      remove_cv
/usr/include/CGAL/Lazy.h:831:39: error: ‘remove_reference_t’ is not a member of ‘std’; did you mean ‘remove_reference’?
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                       ^~~~~~~~~~~~~~~~~~
      |                                       remove_reference
/usr/include/CGAL/Lazy.h:831:89: error: template argument 1 is invalid
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                                                                                         ^~
/usr/include/CGAL/Lazy.h:831:3: error: invalid use of template-name ‘CGAL::Lazy_exact_nt’ without an argument list
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |   ^~~~~~~~~~~~~
/usr/include/CGAL/Lazy.h:831:3: note: class template argument deduction is only available with ‘-std=c++17’ or ‘-std=gnu++17’
In file included from /usr/include/CGAL/Lazy_exact_nt.h:33,
                 from /usr/include/CGAL/internal/Exact_type_selector.h:25,
                 from /usr/include/CGAL/Exact_kernel_selector.h:26,
                 from /usr/include/CGAL/Filtered_kernel.h:22,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:21,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Sizing_fields.h:4,
                 from /home/james/Mesher/src/Sizing_fields.cpp:4:
/usr/include/CGAL/Lazy.h:61:7: note: ‘template<class ET_> class CGAL::Lazy_exact_nt’ declared here
   61 | class Lazy_exact_nt;
      |       ^~~~~~~~~~~~~
In file included from /usr/include/CGAL/Lazy_exact_nt.h:33,
                 from /usr/include/CGAL/internal/Exact_type_selector.h:25,
                 from /usr/include/CGAL/Exact_kernel_selector.h:26,
                 from /usr/include/CGAL/Filtered_kernel.h:22,
                 from /usr/include/CGAL/Exact_predicates_inexact_constructions_kernel.h:21,
                 from /home/james/Mesher/src/CGAL_include.h:7,
                 from /home/james/Mesher/src/Sizing_fields.h:4,
                 from /home/james/Mesher/src/Sizing_fields.cpp:4:
/usr/include/CGAL/Lazy.h:831:16: error: expected initializer before ‘<’ token
  831 |   Lazy_exact_nt<std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>>>
      |                ^
In file included from /usr/include/CGAL/Triangulation_data_structure_3.h:35,
                 from /usr/include/CGAL/Triangulation_3.h:39,
                 from /usr/include/CGAL/Regular_triangulation_3.h:40,
                 from /usr/include/CGAL/Mesh_triangulation_3.h:26,
                 from /home/james/Mesher/src/CGAL_include.h:10,
                 from /home/james/Mesher/src/Sizing_fields.h:4,
                 from /home/james/Mesher/src/Sizing_fields.cpp:4:
/usr/include/CGAL/iterator.h:663:16: error: ‘decay_t’ in namespace ‘std’ does not name a template type; did you mean ‘decay’?
  663 |   typedef std::decay_t<typename cpp11::result_of<Op(arg_type)>::type> value_type;
      |                ^~~~~~~
      |                decay
/usr/include/CGAL/iterator.h:665:11: error: ‘value_type’ does not name a type; did you mean ‘arg_type’?
  665 |   typedef value_type const*                                     pointer;
      |           ^~~~~~~~~~
      |           arg_type
/usr/include/CGAL/iterator.h:666:11: error: ‘value_type’ does not name a type; did you mean ‘arg_type’?
  666 |   typedef value_type const&                                     reference;
      |           ^~~~~~~~~~
      |           arg_type
/usr/include/CGAL/iterator.h:671:11: error: ‘value_type’ does not name a type; did you mean ‘arg_type’?
  671 |   mutable value_type val;  // Note: mutable is needed because we want to
      |           ^~~~~~~~~~
      |           arg_type
/usr/include/CGAL/iterator.h:699:9: error: ‘value_type’ does not name a type; did you mean ‘arg_type’?
  699 |   const value_type& operator*() const {
      |         ^~~~~~~~~~
      |         arg_type
/usr/include/CGAL/iterator.h:715:9: error: ‘value_type’ does not name a type; did you mean ‘arg_type’?
  715 |   const value_type& operator[](difference_type i) const {
      |         ^~~~~~~~~~
      |         arg_type
/usr/include/CGAL/iterator.h:1321:44: error: ‘std::index_sequence’ has not been declared
 1321 | auto to_tuple(std::tuple<Args...> &t, std::index_sequence<Is...>)
      |                                            ^~~~~~~~~~~~~~
/usr/include/CGAL/iterator.h:1321:58: error: expected ‘,’ or ‘...’ before ‘<’ token
 1321 | auto to_tuple(std::tuple<Args...> &t, std::index_sequence<Is...>)
      |                                                          ^
/usr/include/CGAL/iterator.h:1321:1: error: ‘to_tuple’ function uses ‘auto’ type specifier without trailing return type
 1321 | auto to_tuple(std::tuple<Args...> &t, std::index_sequence<Is...>)
      | ^~~~
/usr/include/CGAL/iterator.h:1321:1: note: deduced return type only available with ‘-std=c++14’ or ‘-std=gnu++14’
/usr/include/CGAL/iterator.h: In member function ‘CGAL::Dispatch_output_iterator<std::tuple<_Tps ...>, std::tuple<_Elements ...> >::operator std::tuple<O& ...>()’:
/usr/include/CGAL/iterator.h:1414:49: error: ‘index_sequence_for’ is not a member of ‘std’
 1414 |     return tuple_internal::to_tuple(*this, std::index_sequence_for<O...>{});
      |                                                 ^~~~~~~~~~~~~~~~~~
/usr/include/CGAL/iterator.h:1414:69: error: expected primary-expression before ‘...’ token
 1414 |     return tuple_internal::to_tuple(*this, std::index_sequence_for<O...>{});
      |                                                                     ^~~
/usr/include/CGAL/iterator.h: In member function ‘CGAL::Dispatch_output_iterator<std::tuple<_Tps ...>, std::tuple<_Elements ...> >::operator std::tuple<const O& ...>() const’:
/usr/include/CGAL/iterator.h:1419:49: error: ‘index_sequence_for’ is not a member of ‘std’
 1419 |     return tuple_internal::to_tuple(*this, std::index_sequence_for<O...>{});
      |                                                 ^~~~~~~~~~~~~~~~~~
/usr/include/CGAL/iterator.h:1419:69: error: expected primary-expression before ‘...’ token
 1419 |     return tuple_internal::to_tuple(*this, std::index_sequence_for<O...>{});
      |                                                                     ^~~
In file included from /home/james/Mesher/src/Sizing_fields.h:4,
                 from /home/james/Mesher/src/Sizing_fields.cpp:4:
/home/james/Mesher/src/CGAL_include.h: At global scope:
/home/james/Mesher/src/CGAL_include.h:24:15: warning: ‘template<class Image, class BGT, class Image_word_type_, class Subdomain_index, class Null_subdomain_index, class Wrapper_> class CGAL::Labeled_image_mesh_domain_3’ is deprecated: The class template `CGAL::Labeled_image_mesh_domain_3` is now deprecated. Use the static member function template `Labeled_mesh_domain_3<K>::create_labeled_image_mesh_domain` instead. [-Wdeprecated-declarations]
   24 | typedef CGAL::Labeled_image_mesh_domain_3<CGAL::Image_3,K> Mesh_domain;
      |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /home/james/Mesher/src/CGAL_include.h:14,
                 from /home/james/Mesher/src/Sizing_fields.h:4,
                 from /home/james/Mesher/src/Sizing_fields.cpp:4:
/usr/include/CGAL/Labeled_image_mesh_domain_3.h:50:1: note: declared here
   50 | Labeled_image_mesh_domain_3
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~
make[2]: *** [src/CMakeFiles/mesher.dir/build.make:63: src/CMakeFiles/mesher.dir/Sizing_fields.cpp.o] Error 1
make[1]: *** [CMakeFiles/Makefile2:115: src/CMakeFiles/mesher.dir/all] Error 2
make: *** [Makefile:95: all] Error 2

Do we need to set a different parameter for planar and depth?

Do we need to set a different parameter for planar and depth?
elements_with_fine_sizing_field_percentage = 50

make parameters 'filename' and 'param_file' transferred as Args

gitignore should ignore defaults

rerunning examples should not be tracked

Install latest CGAL (v4.6) in EIT's Linux box

Currently we are working with CGAL 4.2, but EIT is interested in using the latest version of CGAL (4.6), which includes MPI stuff that they'd like to test in the Mesher.

The ppa repositories don't contain that version, but it can be built from scratch. I've gave it a try but was unsuccessful. I didn't spend much time on it though, so I'll give it another try.

Check that expected parameters have been defined

Some parameters have to be defined e.g. depth_refinement = 0 others will only be checked in certain circumstances - sphere_radius is only needed if sphere_refinement is turned on.

At present, if a parameter is missing the program will segfault, should be able to validate the correct options are defined and throw a useful error if not.

Potential Speed Up - Set CMAKE_BUILD_TYPE to "Release"

CMake Warning at /usr/lib/x86_64-linux-gnu/cmake/CGAL/CGAL_enable_end_of_configuration_hook.cmake:99 (message):
  =======================================================================

  CGAL performance notice:

  The variable CMAKE_BUILD_TYPE is set to "".  For performance reasons, you
  should set CMAKE_BUILD_TYPE to "Release".

  Set CGAL_DO_NOT_WARN_ABOUT_CMAKE_BUILD_TYPE to TRUE if you want to disable
  this warning.

  =======================================================================

Add capability to deform mesh

http://doc.cgal.org/latest/Surface_mesh_deformation/

More (any) testing

Sizing fields are confusing

Sizing fields are a bit confused at the moment

"default" refinement is done backwards i.e. smaller elements in the middle. This is also always on, and the option for planar refinement elements_with_fine_sizing_field_percentage is used and is thus confusing
electrode refinement option doesn't do anything and is always on
combination of cuboid and sphere and planar would probably be confusing

remove all TODOs from code

Better Rat Brain example

Current rat brain inr is squashed and lower res than used in papers, need to find a better one

Do some testing/checks on output meshes, vertices, cell centres

We found a bug where the cell vertices/centres weren't matching with the electrode positions.

This was due to an unnecessary multiplication by 'pixel_scale' and should now be fixed. Some tests should be added to catch this kind of error in future.

Branch Proper: make hard-coded parameter free

Link Mesher with relevant MatLab libraries

Kirill's rat Mesher uses some MatLab stuff and the current cmake configuration is not linking MatLab at all. @sinanshi is looking into it. See #1 for more information.

Add input parameters to output parameter file

The parameter output file could have more useful parameter info to keep track of what was used to make the mesh. I forgot after 15minutes, so it would be nice to have a record of this

Combine examples/tests folders

Do they need to be separate?

Add option to scale electrode positions?

Currently electrode positions are not scaled by the pixel_scale i.e. they are specified in the same coordinates as the inr file. However user might want to pick electrode positions on the mesh, and then remesh using these new positions, which would mean these new electrode locations need to put in the inr coordinates before remeshing. I can see this being annoying.

Mesher on Jenkins

Matlab cleanup

Matlab wrapper file should select WSL or not dependent on os
TOAST++ wrapper function
Stl2Inr should cope with multiple stls

CGAL 4.6.1 does not work

CGAL 4.6.1 does not work at all for some reason. It compiles and runs but fail to produce result, freezes at make_mesh_3 and not producing any exceptions.

Need to investigate...

Improved documentation and examples

Readme should have pictures of examples
examples should have pictures
link to paraview and detail how user can replicate pictures
how to get inr from Seg3D (from iso2mesh)
Mesh into PEITS
Mesh into EIDORS
Mesh into TOAST++

Readme improvements

Docker instructions could be improved

check input and output folders correct
add creating tag step to docker instructions
suggest better to leave file in container and copy out rather than map
EIDORS example has wrote contact impedance (not set per m2)

Make callable from command line

Clarify ordering in which sizing field is applied

Allow for multiple sizing fields to be applied at the same time correctly

'no rule to make target libz.so' error when building

This is a problem to do with symlinks

The target file/usr/lib/x86_64-linux-gnu/libz.so is a symlink to another file, which is itself a symlink to an actual file.

The chain ends at /lib/x86_64-linux-gnu/libz.so, which is the 'real' file.

To solve the problem, overwrite the symlink in /usr/lib/x86_64-linux-gnu/libz.so with the actual file /lib/x86_64-linux-gnu/libz.so

PEITS parameter file is missing some things

The .parameters output file contains too many outputs to work with PEITS. Added in bc5c7a0 this was done to have a log of the inputs used. However, PEITS is very picky about what can be in this parameters file so these extra lines need to be removed or commented out.
The .parameter file for PEITS needs to look like this output of dune_exporter :

##### Parameters for NN2016_Tank #####
# no. elements: 4535578 # no. nodes: 805844 #

fem.io.macroGrid: NN2016_Tank.dgf

electrode.use_node_assignment: false

electrode.positions: ../data/electrode_positions_NN2016_Tank

electrode.nodes: ../data/electrode_nodes_TA052_meters
surface.coordinates: ../data/surface_coordinates_TA052_precise

ground.hsquared: 1.5e-5
groundposition.x: 0.012778597804854869
groundposition.y: -0.134296297966862405
groundposition.z: 0.461560081236734254

fem.assign_conductivities: false

this would avoid having to load the mesh into matlab and rewrite the dgf.

Currently the function save_parameters writes everything in the parameters map to a file.
Either the .parameter file should comment out all the unnecessary entries, or the meshing parameters should be written to a separate log file.

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.