morphio 2.1.4__tar.gz → 2.2.0__tar.gz

{MorphIO-2.1.4 → MorphIO-2.2.0}/MorphIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: MorphIO
-Version: 2.1.4
+Version: 2.2.0
 Summary: A neuron morphology IO library
 Home-page: https://github.com/BlueBrain/MorphIO/
 Author: NSE Team - Blue Brain Project

{MorphIO-2.1.4 → MorphIO-2.2.0}/MorphIO.egg-info/SOURCES.txt

@@ -479,7 +479,6 @@ src/morphology.cpp
 src/properties.cpp
 src/section.cpp
 src/soma.cpp
-src/tools.cpp
 src/vector_utils.cpp
 src/version.cpp
 src/version.cpp.in
@@ -525,6 +524,7 @@ tests/data/disconnected_neurite.swc
 tests/data/iterators.asc
 tests/data/multiple_point_section.asc
 tests/data/multiple_soma.swc
+tests/data/nested_single_children.asc
 tests/data/neurite_wrong_root_point.swc
 tests/data/nrn_ordering.swc
 tests/data/reversed_NRN_neurite_order.swc

{MorphIO-2.1.4 → MorphIO-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: MorphIO
-Version: 2.1.4
+Version: 2.2.0
 Summary: A neuron morphology IO library
 Home-page: https://github.com/BlueBrain/MorphIO/
 Author: NSE Team - Blue Brain Project

{MorphIO-2.1.4 → MorphIO-2.2.0}/binds/python/bind_immutable.cpp

@@ -23,21 +23,6 @@ static void bind_immutable_module(py::module &m) {
         .def(py::init<const morphio::URI&, unsigned int>(),
              "filename"_a, "options"_a=morphio::enums::Option::NO_MODIFIER)
         .def(py::init<morphio::mut::Morphology&>())
-        .def("__eq__", [](const morphio::Morphology& a, const morphio::Morphology& b) {
-                return a.operator==(b);
-            }, py::is_operator(),
-            "Are considered equal, 2 morphologies with the same:\n"
-            "- point vector\n"
-            "- diameter vector\n"
-            "- perimeter vector\n"
-            "- cell family\n"
-            "- section types\n"
-            "- topology (children/parent relationship)\n\n"
-            "Note: the soma types are NOT required to be equal")
-        .def("__ne__", [](const morphio::Morphology& a, const morphio::Morphology& b) {
-                return a.operator!=(b);
-            }, py::is_operator())
-        .def(py::self != py::self)
 
         .def("as_mutable", [](const morphio::Morphology* morph) { return morphio::mut::Morphology(*morph); })
 
@@ -146,12 +131,6 @@ static void bind_immutable_module(py::module &m) {
                                "Note: the soma surface computation depends on the soma type");
 
     py::class_<morphio::Section>(m, "Section")
-        .def("__eq__", [](const morphio::Section& a, const morphio::Section& b) {
-                return a.operator==(b);
-            }, py::is_operator())
-        .def("__ne__", [](const morphio::Section& a, const morphio::Section& b) {
-                return a.operator!=(b);
-            }, py::is_operator())
         .def("__str__", [](const morphio::Section& section) {
                 std::stringstream ss;
                 ss << section;

{MorphIO-2.1.4 → MorphIO-2.2.0}/binds/python/bind_misc.cpp

@@ -217,16 +217,4 @@ static void bind_misc(py::module &m) {
              "neuronal_section_ids"_a, "distances_to_section_start"_a, "diameters"_a);
 
     m.doc() = "pybind11 example plugin"; // optional module docstring
-
-
-  m.def("diff", static_cast<bool (*)(const morphio::Morphology& left, const morphio::Morphology& right, morphio::enums::LogLevel logLevel)>(&morphio::diff),
-        "Perform a diff on 2 morphologies, returns True if items differ", "left"_a, "right"_a, "log_level"_a=morphio::enums::LogLevel::INFO);
-  m.def("diff", static_cast<bool (*)(const morphio::Section& left, const morphio::Section& right, morphio::enums::LogLevel logLevel)>(&morphio::diff),
-        "Perform a diff on 2 sections, returns True if items differ", "left"_a, "right"_a, "log_level"_a=morphio::enums::LogLevel::INFO);
-
-  m.def("diff", static_cast<bool (*)(const morphio::mut::Morphology& left, const morphio::mut::Morphology& right, morphio::enums::LogLevel logLevel)>(&morphio::mut::diff),
-        "Perform a diff on 2 morphologies, returns True if items differ", "left"_a, "right"_a, "log_level"_a=morphio::enums::LogLevel::INFO);
-  m.def("diff", static_cast<bool (*)(const morphio::mut::Section& left, const morphio::mut::Section& right, morphio::enums::LogLevel logLevel)>(&morphio::mut::diff),
-        "Perform a diff on 2 sections, returns True if items differ", "left"_a, "right"_a, "log_level"_a=morphio::enums::LogLevel::INFO);
-
 }

{MorphIO-2.1.4 → MorphIO-2.2.0}/binds/python/bind_mutable.cpp

@@ -20,23 +20,6 @@ static void bind_mutable_module(py::module &m) {
         .def(py::init<const morphio::mut::Morphology&, unsigned int>(),
              "morphology"_a, "options"_a=morphio::enums::Option::NO_MODIFIER)
 
-        .def("__eq__", [](const morphio::mut::Morphology& a, const morphio::mut::Morphology& b) {
-                return a.operator==(b);
-            }, py::is_operator(),
-            "Are considered equal, 2 morphologies with the same:\n"
-            "- root sections\n"
-            "- section topology\n"
-            "- cell family\n"
-            "For each section:"
-            "- same points\n"
-            "- same diameters\n"
-            "- same perimeters\n"
-            "- same type\n"
-            "Note: the soma types are NOT required to be equal")
-        .def("__ne__", [](const morphio::mut::Morphology& a, const morphio::mut::Morphology& b) {
-                return a.operator!=(b);
-            }, py::is_operator())
-
         // Cell sub-part accessors
         .def_property_readonly("sections", &morphio::mut::Morphology::sections,
                                "Returns a list containing IDs of all sections. "
@@ -226,12 +209,6 @@ static void bind_mutable_module(py::module &m) {
              "immutable_section"_a, "recursive"_a=false);
 
     py::class_<morphio::mut::Section, std::shared_ptr<morphio::mut::Section>>(m, "Section")
-        .def("__eq__", [](const morphio::mut::Section& a, const morphio::mut::Section& b) {
-                return a.operator==(b);
-            }, py::is_operator())
-        .def("__ne__", [](const morphio::mut::Section& a, const morphio::mut::Section& b) {
-                return a.operator!=(b);
-                }, py::is_operator())
         .def("__str__", [](const morphio::mut::Section& section) {
                 std::stringstream ss;
                 ss << section;

{MorphIO-2.1.4 → MorphIO-2.2.0}/binds/python/bind_vasculature.cpp

@@ -20,19 +20,6 @@ static void bind_vasculature(py::module &m) {
         .def(py::init<const morphio::URI&>(),
              "filename"_a)
         // .def(py::init<morphio::mut::Morphology&>())
-        .def("__eq__", [](const morphio::vasculature::Vasculature& a, const morphio::vasculature::Vasculature& b) {
-                return a.operator==(b);
-            }, py::is_operator(),
-            "Are considered equal, 2 morphologies with the same:\n"
-            "- point vector\n"
-            "- diameter vector\n"
-            "- section types\n"
-            "- topology\n")
-        .def("__ne__", [](const morphio::vasculature::Vasculature& a, const morphio::vasculature::Vasculature& b) {
-                return a.operator!=(b);
-            }, py::is_operator())
-        .def(py::self != py::self)
-
         // .def("as_mutable", [](const morphio::vasculature::VasculatureMorphology* morph) { return morphio::mut::Morphology(*morph); })
 
         .def_property_readonly("sections", &morphio::vasculature::Vasculature::sections,

{MorphIO-2.1.4 → MorphIO-2.2.0}/include/morphio/morphology.h

@@ -26,22 +26,6 @@ public:
     Morphology(Morphology&&);
     Morphology& operator=(Morphology&&);
 
-    /**
-       Equality operator:
-           Are considered equal, 2 morphologies with the same:
-               - point vector
-               - diameter vector
-               - perimeter vector
-               - cell family
-               - section types
-               - topology (children/parent relationship)
-
-           Note: the soma types are NOT required to be equal
-     **/
-    bool operator==(const Morphology& other) const;
-    bool operator!=(const Morphology& other) const;
-
-
     /** @name Read API */
     //@{
     /** Open the given source to a morphology file and parse it.

{MorphIO-2.1.4 → MorphIO-2.2.0}/include/morphio/mut/morphology.h

@@ -56,21 +56,6 @@ public:
 
     virtual ~Morphology();
 
-    /**
-    Are considered equal, 2 morphologies with the same:\n
-     - root sections
-     - section topology
-     - cell family
-     For each section:
-     - same points
-     - same diameters
-     - same perimeters
-     - same type
-     Note: the soma types are NOT required to be equal
-     **/
-    bool operator==(const Morphology& other) const;
-    bool operator!=(const Morphology& other) const;
-
     /**
        Returns all section ids at the tree root
     **/

{MorphIO-2.1.4 → MorphIO-2.2.0}/include/morphio/mut/section.h

@@ -96,16 +96,6 @@ public:
         const Property::PointLevel&,
         SectionType sectionType = SectionType::SECTION_UNDEFINED);
 
-    /**
-    Two sections are equal if they have same:
-    - points
-    - diameters
-    - perimeters
-    - type
-    **/
-    bool operator==(const Section& other) const;
-    bool operator!=(const Section& other) const;
-
 private:
     friend class Morphology;
 

{MorphIO-2.1.4 → MorphIO-2.2.0}/include/morphio/section.h

@@ -33,18 +33,6 @@ class Section : public SectionBase<Section>
     using PointAttribute = Property::Point;
 
 public:
-    /**
-       Equality operator:
-       Are considered equal, 2 sections with the same:
-       - point vector
-       - diameter vector
-       - perimeter vector
-       - section types
-       - topology (children/parent relationship)
-    **/
-    bool operator==(const Section& other) const;
-    bool operator!=(const Section& other) const;
-
     /**
        Depth first search iterator
     **/

{MorphIO-2.1.4 → MorphIO-2.2.0}/include/morphio/vasc/vasculature.h

@@ -15,17 +15,6 @@ public:
     Vasculature(Vasculature&&);
     Vasculature& operator=(Vasculature&&);
 
-    /**
-        Equality operators :
-        Two vasculature morphologies are considered equal if they have the same:
-            - point vector
-            - diameter vector
-            - section types
-            - topology (successor / predecessor relationship)
-    **/
-    bool operator==(const Vasculature& other) const;
-    bool operator!=(const Vasculature& other) const;
-
     /** @name Read API */
     /** Open the given source to a vasculature file and parse it.
      */

{MorphIO-2.1.4 → MorphIO-2.2.0}/setup.py

@@ -1,15 +1,13 @@
+'''morphio setup.py'''
 import os
 import platform
 import re
 import subprocess
 import sys
-import sysconfig
 from distutils.version import LooseVersion
-from shutil import copyfile, copymode
 
-from setuptools import Extension, find_packages, setup
+from setuptools import Extension, setup
 from setuptools.command.build_ext import build_ext
-from setuptools.command.test import test as TestCommand
 
 
 class CMakeExtension(Extension):
@@ -62,8 +60,6 @@ class CMakeBuild(build_ext):
         if not os.path.exists(self.build_temp):
             os.makedirs(self.build_temp)
         try:
-            proc = subprocess.Popen(
-                "echo $CXX", shell=True, stdout=subprocess.PIPE)
             output = subprocess.check_call([cmake, ext.sourcedir] + cmake_args,
                                            cwd=self.build_temp)
             output = subprocess.check_call([cmake, '--build', '.'] + build_args,

{MorphIO-2.1.4 → MorphIO-2.2.0}/src/CMakeLists.txt

@@ -13,7 +13,6 @@ set(MORPHIO_SOURCES
   morphology.cpp
   soma.cpp
   section.cpp
-  tools.cpp
   vasc/section.cpp
   vasc/vasculature.cpp
   vasc/properties.cpp

{MorphIO-2.1.4 → MorphIO-2.2.0}/src/morphology.cpp

@@ -79,16 +79,6 @@ Morphology::~Morphology()
 {
 }
 
-bool Morphology::operator==(const Morphology& other) const
-{
-    return !diff(*this, other, LogLevel::ERROR);
-}
-
-bool Morphology::operator!=(const Morphology& other) const
-{
-    return diff(*this, other, LogLevel::ERROR);
-}
-
 const Soma Morphology::soma() const
 {
     return Soma(_properties);

{MorphIO-2.1.4 → MorphIO-2.2.0}/src/mut/morphology.cpp

@@ -267,8 +267,12 @@ void Morphology::sanitize(const morphio::plugin::DebugInfo& debugInfo)
 {
     morphio::plugin::ErrorMessages err(debugInfo._filename);
 
-    for (auto it = depth_begin(); it != depth_end(); ++it) {
+    auto it = depth_begin();
+    while (it != depth_end()) {
         std::shared_ptr<Section> section_ = *it;
+
+        // Incrementing iterator here before we potentially delete the section
+        ++it;
         unsigned int sectionId = section_->id();
 
         if (section_->isRoot())
@@ -413,15 +417,5 @@ void Morphology::write(const std::string& filename)
         LBTHROW(UnknownFileType(_err.ERROR_WRONG_EXTENSION(filename)));
 }
 
-bool Morphology::operator==(const Morphology& other) const
-{
-    return !diff(*this, other, LogLevel::ERROR);
-}
-
-bool Morphology::operator!=(const Morphology& other) const
-{
-    return diff(*this, other, LogLevel::ERROR);
-}
-
 } // end namespace mut
 } // end namespace morphio

{MorphIO-2.1.4 → MorphIO-2.2.0}/src/mut/section.cpp

@@ -203,16 +203,6 @@ std::shared_ptr<Section> Section::appendSection(
     return ptr;
 }
 
-bool Section::operator==(const Section& other) const
-{
-    return !diff(*this, other, LogLevel::ERROR);
-}
-
-bool Section::operator!=(const Section& other) const
-{
-    return diff(*this, other, LogLevel::ERROR);
-}
-
 } // end namespace mut
 } // end namespace morphio
 

{MorphIO-2.1.4 → MorphIO-2.2.0}/src/section.cpp

@@ -5,16 +5,6 @@
 
 namespace morphio {
 
-bool Section::operator==(const Section& other) const
-{
-    return !diff(*this, other, LogLevel::ERROR);
-}
-
-bool Section::operator!=(const Section& other) const
-{
-    return diff(*this, other, LogLevel::ERROR);
-}
-
 SectionType Section::type() const
 {
     auto val = _properties->get<Property::SectionType>()[_id];

{MorphIO-2.1.4 → MorphIO-2.2.0}/src/vasc/vasculature.cpp

@@ -46,18 +46,6 @@ Vasculature::~Vasculature()
 {
 }
 
-bool Vasculature::operator==(const Vasculature& other) const
-{
-    if (this->_properties == other._properties)
-        return true;
-    return (this->_properties && other._properties && *(this->_properties) == *(other._properties));
-}
-
-bool Vasculature::operator!=(const morphio::vasculature::Vasculature& other) const
-{
-    return !this->operator==(other);
-}
-
 const Section Vasculature::section(const uint32_t& id) const
 {
     return Section(id, _properties);

{MorphIO-2.1.4 → MorphIO-2.2.0}/src/version.cpp

@@ -3,5 +3,5 @@
 #include <morphio/types.h>
 namespace morphio
 {
-  const std::string VERSION("2.1.4");
+  const std::string VERSION("2.1.6.dev1+gd2d117a.d20190717");
 }

MorphIO-2.2.0/tests/data/nested_single_children.asc

@@ -0,0 +1,19 @@
+("CellBody"
+  (CellBody)
+  (0 0 0 1)
+)
+
+( (Color Blue)
+  (Axon)
+  (0 0 0 1)
+  (0 0 1 1)
+  (
+    (0 0 2 1)
+    (
+      (0 0 3 1)
+      (
+        (0 0 4 1)
+      )
+    )
+  )
+)

{MorphIO-2.1.4 → MorphIO-2.2.0}/tests/test_1_swc.py

@@ -289,30 +289,19 @@ def test_soma_type():
 
 def test_read_weird_ids():
     '''The ordering of IDs is not required'''
-    with tmp_swc_file('''1 1 0 0 0 3.0 -1
-                         2 3 0 0 2 0.5 1
-                         3 3 0 0 3 0.5 2
-                         4 3 0 0 4 0.5 3
-                         5 3 0 0 5 0.5 4''') as tmp_file:
-
-        normal = Morphology(tmp_file.name)
-
     with tmp_swc_file('''10000 3 0 0 5 0.5 100 # neurite 4th point
                          3 3 0 0 3 0.5 47      # neurite 2nd point
                          10 1 0 0 0 3.0 -1     # soma
                          47 3 0 0 2 0.5 10     # neurite 1st point
                          100 3 0 0 4 0.5 3     # neurite 3rd point
                          ''') as tmp_file:
-        weird = Morphology(tmp_file.name)
-
-    assert_equal(normal, weird)
-
-
-def test_equality():
-    filename = os.path.join(_path, 'simple.swc')
-    nt.ok_(not (Morphology(filename) is Morphology(filename)))
-    nt.ok_(Morphology(filename) == Morphology(filename))
+        neuron = Morphology(tmp_file.name)
 
+    assert_array_equal(neuron.soma.points, [[0, 0, 0]])
+    assert_array_equal(neuron.root_sections[0].points, [[0., 0., 2.],
+                                                        [0., 0., 3.],
+                                                        [0., 0., 4.],
+                                                        [0., 0., 5.]])
 
 def test_multiple_soma():
     with assert_raises(SomaError) as obj:

{MorphIO-2.1.4 → MorphIO-2.2.0}/tests/test_2_neurolucida.py

@@ -255,6 +255,18 @@ def test_empty_sibling():
     assert_array_equal(annotation.points, [[3, -10, 0], [0, -10, 0], [-3, -10, 0]])
     assert_array_equal(annotation.diameters, [2, 2, 2])
 
+def test_nested_single_child():
+    with captured_output() as (_, err):
+        with ostream_redirect(stdout=True, stderr=True):
+            n = Morphology(os.path.join(_path, 'nested_single_children.asc'))
+    assert_array_equal(n.root_sections[0].points,
+                       [[0., 0., 0.],
+                        [0., 0., 1.],
+                        [0., 0., 2.],
+                        [0., 0., 3.],
+                        [0., 0., 4.]])
+
+
 
 
 def test_section_single_point():
@@ -365,17 +377,10 @@ def test_single_point_section_duplicate_parent():
                       )
                      )''') as tmp_file:
 
-        bad = Morphology(tmp_file.name)
-
-    with tmp_asc_file('''
-                     ((Dendrite)
-                      (3 -4 0 2)
-                      (3 -10 0 2)
-                     )''') as tmp_file:
-
-        good = Morphology(tmp_file.name)
+        neuron = Morphology(tmp_file.name)
 
-        assert_equal(bad, good)
+    assert_array_equal(neuron.root_sections[0].points, [[  3.,  -4.,   0.],
+                                                        [  3., -10.,   0.]])
 
 
 def test_single_point_section_duplicate_parent_complex():
@@ -402,26 +407,13 @@ def test_single_point_section_duplicate_parent_complex():
   )
  )
 ''') as bad_tmp_file:
-        bad = Morphology(bad_tmp_file.name)
+        neuron = Morphology(bad_tmp_file.name)
 
-    # Correct representation should be
-    with tmp_asc_file('''
-((Color Blue)
- (Axon)
-    (1 0 0 1)
-    (2 0 0 1)
-    (
-      (4 0 0 1)
-      |
-      (5 0 0 1)
-      |           ; Bifurcation of the bifurcation
-      (6 0 0 1)
-    )
- )
-''') as good_tmp_file:
-        good = Morphology(good_tmp_file.name)
-
-    ok_(good == bad)
+    children = neuron.root_sections[0].children
+    assert_equal(len(children), 3)
+    assert_array_equal(children[0].points, [[2, 0, 0], [4, 0, 0]])
+    assert_array_equal(children[1].points, [[2, 0, 0], [5, 0, 0]])
+    assert_array_equal(children[2].points, [[2, 0, 0], [6, 0, 0]])
 
 
 def test_spine():
@@ -437,10 +429,6 @@ def test_spine():
                                  [13.75,    -5.96,   150.00]], dtype=np.float32))
 
 
-def test_equality_with_simple():
-    ok_(Morphology(os.path.join(_path, 'simple.asc')) ==
-        Morphology(os.path.join(_path, 'simple.swc')))
-
 
 def test_markers():
     '''Test that markers do not prevent file from being read correctly'''

{MorphIO-2.1.4 → MorphIO-2.2.0}/tests/test_4_immut.py

@@ -19,11 +19,6 @@ CELLS = OrderedDict({
 })
 
 
-def test_equality():
-    for cell1, cell2 in combinations(['asc', 'swc', 'h5'], 2):
-        ok_(CELLS[cell1] == CELLS[cell2], '{} != {}'.format(cell1, cell2))
-
-
 def test_is_root():
     for _, cell in CELLS.items():
         ok_(all(section.is_root for section in cell.root_sections))
@@ -97,15 +92,6 @@ def test_empty_vasculature():
     assert_raises(RawDataError, vasculature.Vasculature, os.path.join(_path, "h5/empty_vasculature.h5"))
 
 
-def test_equality_vasculature():
-    morphology1 = vasculature.Vasculature(os.path.join(_path, "h5/vasculature1.h5"))
-    morphology1_bis = vasculature.Vasculature(os.path.join(_path, "h5/vasculature1.h5"))
-    morphology2 = vasculature.Vasculature(os.path.join(_path, "h5/vasculature2.h5"))
-
-    assert_equal(morphology1, morphology1_bis)
-    assert_not_equal(morphology1, morphology2)
-
-
 def test_components_vasculature():
     morphology = vasculature.Vasculature(os.path.join(_path, "h5/vasculature1.h5"))
     assert_array_almost_equal(morphology.section(0).points,

{MorphIO-2.1.4 → MorphIO-2.2.0}/tests/test_5_mut.py

@@ -5,7 +5,7 @@ from nose.tools import assert_equal, assert_raises, ok_, assert_not_equal
 
 import morphio
 from morphio.mut import Morphology, Soma
-from morphio import ostream_redirect, MitochondriaPointLevel, PointLevel, SectionType, MorphioError, SectionBuilderError, Morphology as ImmutableMorphology, upstream, depth_first, breadth_first, diff
+from morphio import ostream_redirect, MitochondriaPointLevel, PointLevel, SectionType, MorphioError, SectionBuilderError, Morphology as ImmutableMorphology, upstream, depth_first, breadth_first
 from contextlib import contextmanager
 import sys
 from io import StringIO
@@ -310,77 +310,6 @@ def test_mitochondria():
     assert_array_equal(np.array(first_child.relative_path_lengths, dtype=np.float32),
                        np.array([0.6, 0.7, 0.8, 0.9], dtype=np.float32))
 
-def test_equality():
-    neuron_ref = Morphology(os.path.join(_path, 'simple2.asc'))
-    a = Morphology(os.path.join(_path, 'simple2.asc'))
-    assert_equal(neuron_ref, a)
-    ok_(not (neuron_ref != a))
-    ok_(not diff(neuron_ref, a))
-
-    def mundane_section(neuron):
-        '''Not a root section, not a leaf section'''
-        return neuron.root_sections[0].children[0]
-
-    def assert_expect_diff(neuron1, neuron2, expected_msg):
-        '''Expect diff to find a difference and return EXPECTED_MSG in stdout'''
-        with captured_output() as (out, _):
-            with ostream_redirect(stdout=True, stderr=True):
-                ok_(diff(neuron1, neuron2))
-                assert_equal(out.getvalue().strip(), expected_msg)
-
-        with captured_output() as (out, _):
-            with ostream_redirect(stdout=True, stderr=True):
-                ok_(diff(neuron1.as_immutable(), neuron2.as_immutable()))
-                assert_equal(out.getvalue().strip(), expected_msg)
-
-    mundane_section(a).type = SectionType.apical_dendrite
-    assert_not_equal(neuron_ref, a)
-    ok_(not (neuron_ref == a))
-    assert_expect_diff(neuron_ref, a,
-                       'Reason: section type differ\n'
-                       'Summary: children of Section(id=0, points=[(0 0 0),..., (0 5 0)]) differ. '
-                       'See the above "Reason" to know in what they differ.')
-
-    a = Morphology(os.path.join(_path, 'simple2.asc'))
-    mundane_section(a).points = [[0,0,0], [0,0,0], [0,0,1]]
-    assert_not_equal(neuron_ref, a)
-    ok_(not (neuron_ref == a))
-    assert_expect_diff(neuron_ref, a,
-                       'Reason: points differ\n'
-                       'Summary: children of Section(id=0, points=[(0 0 0),..., (0 5 0)]) differ. '
-                       'See the above "Reason" to know in what they differ.')
-
-    a = Morphology(os.path.join(_path, 'simple2.asc'))
-    mundane_section(a).diameters = [0,0,0]
-    assert_not_equal(neuron_ref, a)
-    ok_(not (neuron_ref == a))
-    assert_expect_diff(neuron_ref, a,
-                       'Reason: diameters differ\n'
-                       'Summary: children of Section(id=0, points=[(0 0 0),..., (0 5 0)]) differ. '
-                       'See the above "Reason" to know in what they differ.')
-
-    a = Morphology(os.path.join(_path, 'simple2.asc'))
-    for section in a.iter():
-        section.perimeters = [1] * len(section.points)
-    assert_not_equal(neuron_ref, a)
-    ok_(not (neuron_ref == a))
-    assert_expect_diff(neuron_ref, a, 'Reason: perimeters differ')
-
-    a = Morphology(os.path.join(_path, 'simple2.asc'))
-    mundane_section(a).append_section(PointLevel([[-6, 5, 0], [4, 5, 6]], [2, 3]))
-    assert_not_equal(neuron_ref, a)
-    ok_(not (neuron_ref == a))
-    assert_expect_diff(neuron_ref, a,
-                       'Reason: different number of children\n'
-                       'Summary: children of Section(id=0, points=[(0 0 0),..., (0 5 0)]) differ. '
-                       'See the above "Reason" to know in what they differ.')
-
-    a = Morphology(os.path.join(_path, 'simple2.asc'))
-    a.delete_section(a.root_sections[0])
-    assert_not_equal(neuron_ref, a)
-    ok_(not (neuron_ref == a))
-    assert_expect_diff(neuron_ref, a, "Different number of root sections")
-
 
 def test_iterators():
     assert_array_equal([sec.id for sec in SIMPLE.section(5).iter(upstream)],